# typed: false

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


class Bundler::Dependency < ::Gem::Dependency
  include ::Tapioca::BundlerExt::AutoRequireHook
end

class GitAttributes
  class << self
    sig { params(path: ::Pathname).void }
    def create_generated_attribute_file(path); end

    sig { params(path: ::Pathname).void }
    def create_vendored_attribute_file(path); end

    private

    sig { params(path: ::Pathname, content: ::String).void }
    def create_gitattributes_file(path, content); end
  end
end

class Module
  def append_features(constant); end
  def autoload(const_name, path); end
  def const_added(cname); end
  def extend_object(obj); end
  def prepend_features(constant); end
end

module RBI; end

class RBI::Tree < ::RBI::NodeWithComments
  sig do
    params(
      name: ::String,
      superclass_name: T.nilable(::String),
      block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
    ).returns(::RBI::Scope)
  end
  def create_class(name, superclass_name: T.unsafe(nil), &block); end

  sig { params(name: ::String, value: ::String).void }
  def create_constant(name, value:); end

  sig { params(name: ::String).void }
  def create_extend(name); end

  sig { params(name: ::String).void }
  def create_include(name); end

  sig do
    params(
      name: ::String,
      parameters: T::Array[::RBI::TypedParam],
      return_type: T.nilable(::String),
      class_method: T::Boolean,
      visibility: ::RBI::Visibility,
      comments: T::Array[::RBI::Comment],
      block: T.nilable(T.proc.params(node: ::RBI::Method).void)
    ).void
  end
  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil), comments: T.unsafe(nil), &block); end

  sig { params(name: ::String).void }
  def create_mixes_in_class_methods(name); end

  sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
  def create_module(name, &block); end

  sig do
    params(
      constant: T::Module[T.anything],
      block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
    ).returns(::RBI::Scope)
  end
  def create_path(constant, &block); end

  sig do
    params(
      name: ::String,
      type: ::String,
      variance: ::Symbol,
      fixed: T.nilable(::String),
      upper: T.nilable(::String),
      lower: T.nilable(::String)
    ).void
  end
  def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end

  private

  sig { params(node: ::RBI::Node).returns(::RBI::Node) }
  def create_node(node); end

  sig { returns(T::Hash[::String, ::RBI::Node]) }
  def nodes_cache; end
end

class RBI::TypedParam < ::T::Struct
  const :param, ::RBI::Param
  const :type, ::String
end

module T::Generic
  def [](*types); end
  def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
  def type_member(variance = T.unsafe(nil), &bounds_proc); end
  def type_template(variance = T.unsafe(nil), &bounds_proc); end
end

module T::Generic::TypeStoragePatch
  def [](*types); end
  def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
  def type_member(variance = T.unsafe(nil), &bounds_proc); end
  def type_template(variance = T.unsafe(nil), &bounds_proc); end
end

module T::Helpers
  def requires_ancestor(&block); end
end

module T::Private::Casts
  class << self
    def cast(value, type, cast_method); end
  end
end

module T::Private::Casts::TapiocaGenericTypeCastPatch
  def cast(value, type, cast_method); end
end

module T::Private::Methods
  class << self
    def finalize_proc(decl); end
  end
end

module T::Private::Methods::ProcBindPatch
  def finalize_proc(decl); end
end

class T::Types::Proc < ::T::Types::Base
  def initialize(arg_types, returns, bind = T.unsafe(nil)); end

  def name; end
end

module T::Types::ProcBindPatch
  def initialize(arg_types, returns, bind = T.unsafe(nil)); end

  def name; end
end

class T::Types::Simple < ::T::Types::Base
  def name; end
end

module T::Types::Simple::GenericPatch
  def name; end
end

module T::Types::Simple::NamePatch
  def name; end
end

module T::Utils::Private
  class << self
    def coerce_and_check_module_types(val, check_val, check_module_type); end
  end
end

module T::Utils::Private::TapiocaGenericTypeCoercePatch
  def coerce_and_check_module_types(val, check_val, check_module_type); end
end

module Tapioca; end
Tapioca::BINARY_FILE = T.let(T.unsafe(nil), String)
module Tapioca::BundlerExt; end

module Tapioca::BundlerExt::AutoRequireHook
  requires_ancestor { Bundler::Dependency }

  sig { returns(T.untyped) }
  def autorequire; end

  class << self
    def enabled?; end

    sig { params(name: T.untyped).returns(T::Boolean) }
    def excluded?(name); end

    sig do
      type_parameters(:Result)
        .params(
          exclude: T::Array[::String],
          blk: T.proc.returns(T.type_parameter(:Result))
        ).returns(T.type_parameter(:Result))
    end
    def override_require_false(exclude:, &blk); end
  end
end

Tapioca::CENTRAL_REPO_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
Tapioca::CENTRAL_REPO_INDEX_PATH = T.let(T.unsafe(nil), String)
Tapioca::CENTRAL_REPO_ROOT_URI = T.let(T.unsafe(nil), String)

class Tapioca::Cli < ::Thor
  include ::Tapioca::CliHelper
  include ::Tapioca::ConfigHelper
  include ::Tapioca::EnvHelper

  def __print_version; end
  def annotations; end
  def check_shims; end
  def configure; end
  def dsl(*constant_or_paths); end
  def gem(*gems); end
  def init; end
  def require; end
  def todo; end

  private

  def print_init_next_steps; end

  class << self
    def addon_mode; end

    sig { void }
    def addon_mode!; end

    sig { returns(T::Boolean) }
    def exit_on_failure?; end
  end
end

Tapioca::Cli::FILE_HEADER_OPTION_DESC = T.let(T.unsafe(nil), String)

module Tapioca::CliHelper
  requires_ancestor { Thor::Shell }

  sig { params(options: T::Hash[::Symbol, T.untyped]).returns(T.nilable(::String)) }
  def netrc_file(options); end

  sig { params(options: T::Hash[::Symbol, T.untyped]).returns(::Tapioca::RBIFormatter) }
  def rbi_formatter(options); end

  sig { params(message: ::String, color: T.any(::Symbol, T::Array[::Symbol])).void }
  def say_error(message = T.unsafe(nil), *color); end
end

module Tapioca::Commands; end

class Tapioca::Commands::AbstractDsl < ::Tapioca::Commands::CommandWithoutTracker
  include ::Tapioca::SorbetHelper
  include ::Tapioca::RBIFilesHelper

  abstract!

  sig do
    params(
      requested_constants: T::Array[::String],
      requested_paths: T::Array[::Pathname],
      outpath: ::Pathname,
      only: T::Array[::String],
      exclude: T::Array[::String],
      file_header: T::Boolean,
      tapioca_path: ::String,
      skip_constant: T::Array[::String],
      quiet: T::Boolean,
      verbose: T::Boolean,
      number_of_workers: T.nilable(::Integer),
      auto_strictness: T::Boolean,
      gem_dir: ::String,
      rbi_formatter: ::Tapioca::RBIFormatter,
      app_root: ::String,
      halt_upon_load_error: T::Boolean,
      compiler_options: T::Hash[::String, T.untyped],
      lsp_addon: T::Boolean
    ).void
  end
  def initialize(requested_constants:, requested_paths:, outpath:, only:, exclude:, file_header:, tapioca_path:, skip_constant: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil), number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), gem_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil), compiler_options: T.unsafe(nil), lsp_addon: T.unsafe(nil)); end

  private

  sig { returns(T::Array[::String]) }
  def all_requested_constants; end

  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
  def build_error_for_files(cause, files); end

  sig do
    params(
      constant_name: ::String,
      rbi: ::RBI::File,
      outpath: ::Pathname,
      quiet: T::Boolean
    ).returns(T.nilable(::Pathname))
  end
  def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end

  sig do
    params(
      constant_names: T::Array[::String],
      ignore_missing: T::Boolean
    ).returns(T::Array[T::Module[T.anything]])
  end
  def constantize(constant_names, ignore_missing: T.unsafe(nil)); end

  sig { params(compiler_names: T::Array[::String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
  def constantize_compilers(compiler_names); end

  sig { returns(T::Array[::String]) }
  def constants_from_requested_paths; end

  sig { returns(::Tapioca::Dsl::Pipeline) }
  def create_pipeline; end

  sig { params(constant_name: ::String).returns(::Pathname) }
  def dsl_rbi_filename(constant_name); end

  sig { params(requested_constants: T::Array[::String], path: ::Pathname).returns(T::Set[::Pathname]) }
  def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end

  sig { params(constant: ::String).returns(::String) }
  def generate_command_for(constant); end

  sig { params(outpath: ::Pathname, quiet: T::Boolean).returns(T::Set[::Pathname]) }
  def generate_dsl_rbi_files(outpath, quiet:); end

  sig { void }
  def load_application; end

  sig { params(dir: ::Pathname).void }
  def perform_dsl_verification(dir); end

  sig { returns(::Tapioca::Dsl::Pipeline) }
  def pipeline; end

  sig { params(files: T::Set[::Pathname]).void }
  def purge_stale_dsl_rbi_files(files); end

  sig { params(constant: ::String).returns(::String) }
  def rbi_filename_for(constant); end

  sig { params(path: ::Pathname).returns(T::Array[::Pathname]) }
  def rbi_files_in(path); end

  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
  def report_diff_and_exit_if_out_of_date(diff, command); end

  sig { params(name: ::String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) }
  def resolve(name); end

  sig { params(class_name: ::String).returns(::String) }
  def underscore(class_name); end

  sig { params(tmp_dir: ::Pathname).returns(T::Hash[::String, ::Symbol]) }
  def verify_dsl_rbi(tmp_dir:); end
end

class Tapioca::Commands::AbstractGem < ::Tapioca::Commands::Command
  include ::Tapioca::SorbetHelper
  include ::Tapioca::RBIFilesHelper

  abstract!

  sig do
    params(
      gem_names: T::Array[::String],
      exclude: T::Array[::String],
      include_dependencies: T::Boolean,
      prerequire: T.nilable(::String),
      postrequire: ::String,
      typed_overrides: T::Hash[::String, ::String],
      outpath: ::Pathname,
      file_header: T::Boolean,
      include_doc: T::Boolean,
      include_loc: T::Boolean,
      include_exported_rbis: T::Boolean,
      number_of_workers: T.nilable(::Integer),
      auto_strictness: T::Boolean,
      dsl_dir: ::String,
      rbi_formatter: ::Tapioca::RBIFormatter,
      halt_upon_load_error: T::Boolean,
      lsp_addon: T.nilable(T::Boolean),
      verbose: T.nilable(T::Boolean)
    ).void
  end
  def initialize(gem_names:, exclude:, include_dependencies:, prerequire:, postrequire:, typed_overrides:, outpath:, file_header:, include_doc:, include_loc:, include_exported_rbis:, number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), dsl_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil), lsp_addon: T.unsafe(nil), verbose: T.unsafe(nil)); end

  private

  sig { returns(T::Array[::String]) }
  def added_rbis; end

  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
  def build_error_for_files(cause, files); end

  sig { params(gem: ::Tapioca::Gemfile::GemSpec).void }
  def compile_gem_rbi(gem); end

  sig { params(gem_name: ::String).returns(::Pathname) }
  def existing_rbi(gem_name); end

  sig { returns(T::Hash[::String, ::String]) }
  def existing_rbis; end

  sig { params(gem_name: ::String).returns(::Pathname) }
  def expected_rbi(gem_name); end

  sig { returns(T::Hash[::String, ::String]) }
  def expected_rbis; end

  sig { params(gem_name: ::String).returns(T::Boolean) }
  def gem_rbi_exists?(gem_name); end

  sig { params(gem_name: ::String, version: ::String).returns(::Pathname) }
  def gem_rbi_filename(gem_name, version); end

  sig { params(gem: ::Tapioca::Gemfile::GemSpec, file: ::RBI::File).void }
  def merge_with_exported_rbi(gem, file); end

  sig { params(old_filename: ::Pathname, new_filename: ::Pathname).void }
  def move(old_filename, new_filename); end

  sig { void }
  def perform_additions; end

  sig { void }
  def perform_removals; end

  sig { returns(T::Array[::String]) }
  def removed_rbis; end

  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
  def report_diff_and_exit_if_out_of_date(diff, command); end
end

class Tapioca::Commands::Annotations < ::Tapioca::Commands::CommandWithoutTracker
  sig do
    params(
      central_repo_root_uris: T::Array[::String],
      auth: T.nilable(::String),
      netrc_file: T.nilable(::String),
      central_repo_index_path: ::String,
      typed_overrides: T::Hash[::String, ::String]
    ).void
  end
  def initialize(central_repo_root_uris:, auth: T.unsafe(nil), netrc_file: T.unsafe(nil), central_repo_index_path: T.unsafe(nil), typed_overrides: T.unsafe(nil)); end

  private

  sig { params(name: ::String, content: ::String).returns(::String) }
  def add_header(name, content); end

  sig { params(name: ::String, content: ::String).returns(::String) }
  def apply_typed_override(name, content); end

  sig { override.void }
  def execute; end

  sig { params(repo_uris: T::Array[::String], gem_info: ::Tapioca::GemInfo).returns(T::Boolean) }
  def fetch_annotation(repo_uris, gem_info); end

  sig { params(project_gems: T::Array[::Tapioca::GemInfo]).returns(T::Array[::String]) }
  def fetch_annotations(project_gems); end

  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
  def fetch_file(repo_uri, path); end

  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
  def fetch_http_file(repo_uri, path); end

  sig { params(repo_uri: ::String, repo_number: T.nilable(::Integer)).returns(T.nilable(::Tapioca::RepoIndex)) }
  def fetch_index(repo_uri, repo_number:); end

  sig { returns(T::Hash[::String, ::Tapioca::RepoIndex]) }
  def fetch_indexes; end

  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
  def fetch_local_file(repo_uri, path); end

  sig { params(gem_version: ::Gem::Version, content: ::String).returns(::String) }
  def filter_versions(gem_version, content); end

  sig { returns(T::Array[::Tapioca::GemInfo]) }
  def list_gemfile_gems; end

  sig { params(gem_name: ::String, contents: T::Array[::String]).returns(T.nilable(::String)) }
  def merge_files(gem_name, contents); end

  sig { params(project_gems: T::Array[::Tapioca::GemInfo]).void }
  def remove_expired_annotations(project_gems); end

  sig { returns(T::Hash[::String, T.nilable(::String)]) }
  def repo_tokens; end

  sig { params(path: ::String, repo_uri: ::String, message: ::String).void }
  def say_http_error(path, repo_uri, message:); end

  sig { params(repo_uri: ::String).returns(T.nilable(::String)) }
  def token_for(repo_uri); end
end

class Tapioca::Commands::CheckShims < ::Tapioca::Commands::CommandWithoutTracker
  include ::Tapioca::SorbetHelper
  include ::Tapioca::RBIFilesHelper

  sig do
    params(
      gem_rbi_dir: ::String,
      dsl_rbi_dir: ::String,
      annotations_rbi_dir: ::String,
      shim_rbi_dir: ::String,
      todo_rbi_file: ::String,
      payload: T::Boolean,
      number_of_workers: T.nilable(::Integer)
    ).void
  end
  def initialize(gem_rbi_dir:, dsl_rbi_dir:, annotations_rbi_dir:, shim_rbi_dir:, todo_rbi_file:, payload:, number_of_workers:); end

  private

  sig { override.void }
  def execute; end
end

class Tapioca::Commands::Command
  include ::Thor::Base
  include ::Thor::Invocation
  include ::Thor::Shell
  include ::Tapioca::CliHelper
  extend ::Thor::Base::ClassMethods
  extend ::Thor::Invocation::ClassMethods

  abstract!

  sig { void }
  def initialize; end

  sig { returns(::Thor::Actions) }
  def file_writer; end

  sig(:final) { void }
  def run; end

  private

  sig do
    params(
      path: T.any(::Pathname, ::String),
      content: ::String,
      force: T::Boolean,
      skip: T::Boolean,
      verbose: T::Boolean
    ).void
  end
  def create_file(path, content, force: T.unsafe(nil), skip: T.unsafe(nil), verbose: T.unsafe(nil)); end

  sig { params(command: ::Symbol, args: ::String).returns(::String) }
  def default_command(command, *args); end

  sig { abstract.void }
  def execute; end

  sig { params(path: T.any(::Pathname, ::String), verbose: T::Boolean).void }
  def remove_file(path, verbose: T.unsafe(nil)); end
end

class Tapioca::Commands::Command::FileWriter < ::Thor
  include ::Thor::Actions
  extend ::Thor::Actions::ClassMethods
end

class Tapioca::Commands::CommandWithoutTracker < ::Tapioca::Commands::Command
  abstract!

  sig { void }
  def initialize; end
end

class Tapioca::Commands::Configure < ::Tapioca::Commands::CommandWithoutTracker
  sig { params(sorbet_config: ::String, tapioca_config: ::String, default_postrequire: ::String).void }
  def initialize(sorbet_config:, tapioca_config:, default_postrequire:); end

  private

  sig { void }
  def create_binstub; end

  sig { void }
  def create_post_require; end

  sig { void }
  def create_sorbet_config; end

  sig { void }
  def create_tapioca_config; end

  sig { override.void }
  def execute; end

  sig { returns(::Bundler::Installer) }
  def installer; end

  sig { returns(T.any(::Bundler::StubSpecification, ::Gem::Specification)) }
  def spec; end
end

class Tapioca::Commands::DslCompilerList < ::Tapioca::Commands::AbstractDsl
  private

  sig { override.void }
  def execute; end
end

class Tapioca::Commands::DslGenerate < ::Tapioca::Commands::AbstractDsl
  sig { params(only_bootsnap_rbs_cache: T::Boolean, kwargs: T.untyped).void }
  def initialize(only_bootsnap_rbs_cache: T.unsafe(nil), **kwargs); end

  private

  sig { override.void }
  def execute; end
end

class Tapioca::Commands::DslVerify < ::Tapioca::Commands::AbstractDsl
  private

  sig { override.void }
  def execute; end
end

class Tapioca::Commands::GemGenerate < ::Tapioca::Commands::AbstractGem
  private

  sig { override.void }
  def execute; end

  sig do
    params(
      gem: ::Tapioca::Gemfile::GemSpec,
      dependencies: T::Array[::Tapioca::Gemfile::GemSpec]
    ).returns(T::Array[::Tapioca::Gemfile::GemSpec])
  end
  def gem_dependencies(gem, dependencies = T.unsafe(nil)); end

  sig { params(gem_names: T::Array[::String]).returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
  def gems_to_generate(gem_names); end
end

class Tapioca::Commands::GemSync < ::Tapioca::Commands::AbstractGem
  private

  sig { override.void }
  def execute; end
end

class Tapioca::Commands::GemVerify < ::Tapioca::Commands::AbstractGem
  private

  sig { override.void }
  def execute; end

  sig { void }
  def perform_sync_verification; end
end

class Tapioca::Commands::Require < ::Tapioca::Commands::CommandWithoutTracker
  sig { params(requires_path: ::String, sorbet_config_path: ::String).void }
  def initialize(requires_path:, sorbet_config_path:); end

  private

  sig { override.void }
  def execute; end
end

class Tapioca::Commands::Todo < ::Tapioca::Commands::CommandWithoutTracker
  include ::Tapioca::SorbetHelper

  sig { params(todo_file: ::String, file_header: T::Boolean).void }
  def initialize(todo_file:, file_header:); end

  sig { void }
  def run_with_deprecation; end

  private

  sig { override.void }
  def execute; end

  sig { params(constants: T::Array[::String], command: ::String).returns(::RBI::File) }
  def rbi(constants, command:); end

  sig { returns(T::Array[::String]) }
  def unresolved_constants; end
end

Tapioca::Commands::Todo::DEPRECATION_MESSAGE = T.let(T.unsafe(nil), String)

module Tapioca::ConfigHelper
  requires_ancestor { Thor }

  sig { params(args: T.untyped, local_options: T.untyped, config: T.untyped).void }
  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end

  sig { returns(::String) }
  def command_name; end

  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
  def defaults; end

  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
  def options; end

  private

  sig { params(msg: ::String).returns(::Tapioca::ConfigHelper::ConfigError) }
  def build_error(msg); end

  sig { params(config_file: ::String, errors: T::Array[::Tapioca::ConfigHelper::ConfigError]).returns(::String) }
  def build_error_message(config_file, errors); end

  sig do
    params(
      options: ::Thor::CoreExt::HashWithIndifferentAccess
    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
  end
  def config_options(options); end

  sig { params(options: T::Hash[::Symbol, ::Thor::Option]).void }
  def filter_defaults(options); end

  sig do
    params(
      options: T.nilable(::Thor::CoreExt::HashWithIndifferentAccess)
    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
  end
  def merge_options(*options); end

  sig { params(config_file: ::String, config: T::Hash[T.untyped, T.untyped]).void }
  def validate_config!(config_file, config); end

  sig do
    params(
      command_options: T::Hash[::Symbol, ::Thor::Option],
      config_key: ::String,
      config_options: T::Hash[T.untyped, T.untyped]
    ).returns(T::Array[::Tapioca::ConfigHelper::ConfigError])
  end
  def validate_config_options(command_options, config_key, config_options); end
end

class Tapioca::ConfigHelper::ConfigError < ::T::Struct
  const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart]
end

class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct
  const :message, ::String
  const :colors, T::Array[::Symbol]
end

Tapioca::DEFAULT_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
Tapioca::DEFAULT_DSL_DIR = T.let(T.unsafe(nil), String)
Tapioca::DEFAULT_ENVIRONMENT = T.let(T.unsafe(nil), String)
Tapioca::DEFAULT_GEM_DIR = T.let(T.unsafe(nil), String)
Tapioca::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
Tapioca::DEFAULT_POSTREQUIRE_FILE = T.let(T.unsafe(nil), String)
Tapioca::DEFAULT_RBI_DIR = T.let(T.unsafe(nil), String)
Tapioca::DEFAULT_RBI_FORMATTER = T.let(T.unsafe(nil), Tapioca::RBIFormatter)
Tapioca::DEFAULT_RBI_MAX_LINE_LENGTH = T.let(T.unsafe(nil), Integer)
Tapioca::DEFAULT_SHIM_DIR = T.let(T.unsafe(nil), String)
Tapioca::DEFAULT_TODO_FILE = T.let(T.unsafe(nil), String)
module Tapioca::Dsl; end

class Tapioca::Dsl::Compiler
  extend T::Generic
  include ::Tapioca::SorbetHelper
  include ::Tapioca::RBIHelper
  include ::Tapioca::Runtime::Reflection
  extend ::Tapioca::Runtime::Reflection

  abstract!

  ConstantType = type_member { { upper: T::Module[T.anything] } }

  sig do
    params(
      pipeline: ::Tapioca::Dsl::Pipeline,
      root: ::RBI::Tree,
      constant: ConstantType,
      options: T::Hash[::String, T.untyped]
    ).void
  end
  def initialize(pipeline, root, constant, options = T.unsafe(nil)); end

  sig { params(error: ::String).void }
  def add_error(error); end

  sig { params(compiler_name: ::String).returns(T::Boolean) }
  def compiler_enabled?(compiler_name); end

  sig { returns(ConstantType) }
  def constant; end

  sig { abstract.void }
  def decorate; end

  sig { returns(T::Hash[::String, T.untyped]) }
  def options; end

  sig { returns(::RBI::Tree) }
  def root; end

  private

  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(T::Array[::RBI::TypedParam]) }
  def compile_method_parameters_to_rbi(method_def); end

  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(::String) }
  def compile_method_return_type_to_rbi(method_def); end

  sig { params(scope: ::RBI::Scope, method_def: T.any(::Method, ::UnboundMethod), class_method: T::Boolean).void }
  def create_method_from_def(scope, method_def, class_method: T.unsafe(nil)); end

  sig { params(method_def: T.any(::Method, ::UnboundMethod), signature: T.untyped).returns(T::Array[::String]) }
  def parameters_types_from_signature(method_def, signature); end

  class << self
    sig { abstract.returns(T::Enumerable[T::Module[T.anything]]) }
    def gather_constants; end

    sig { params(constant: T::Module[T.anything]).returns(T::Boolean) }
    def handles?(constant); end

    sig { returns(T::Set[T::Module[T.anything]]) }
    def processable_constants; end

    sig { params(constants: T::Array[T::Module[T.anything]]).void }
    def requested_constants=(constants); end

    sig { void }
    def reset_state; end

    private

    sig { returns(T::Enumerable[T::Class[T.anything]]) }
    def all_classes; end

    sig { returns(T::Enumerable[T::Module[T.anything]]) }
    def all_modules; end

    sig do
      type_parameters(:U)
        .params(
          klass: T.all(T.type_parameter(:U), T::Class[T.anything])
        ).returns(T::Array[T.type_parameter(:U)])
    end
    def descendants_of(klass); end
  end
end

module Tapioca::Dsl::Compilers; end
Tapioca::Dsl::Compilers::NAMESPACES = T.let(T.unsafe(nil), Array)

class Tapioca::Dsl::Pipeline
  sig do
    params(
      requested_constants: T::Array[T::Module[T.anything]],
      requested_paths: T::Array[::Pathname],
      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
      error_handler: T.proc.params(error: ::String).void,
      skipped_constants: T::Array[T::Module[T.anything]],
      number_of_workers: T.nilable(::Integer),
      compiler_options: T::Hash[::String, T.untyped],
      lsp_addon: T::Boolean
    ).void
  end
  def initialize(requested_constants:, requested_paths: T.unsafe(nil), requested_compilers: T.unsafe(nil), excluded_compilers: T.unsafe(nil), error_handler: T.unsafe(nil), skipped_constants: T.unsafe(nil), number_of_workers: T.unsafe(nil), compiler_options: T.unsafe(nil), lsp_addon: T.unsafe(nil)); end

  sig { returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]) }
  def active_compilers; end

  sig { params(error: ::String).void }
  def add_error(error); end

  sig { params(compiler_name: ::String).returns(T::Boolean) }
  def compiler_enabled?(compiler_name); end

  sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
  def compilers; end

  sig { returns(T.proc.params(error: ::String).void) }
  def error_handler; end

  sig { returns(T::Array[::String]) }
  def errors; end

  sig { returns(T::Array[T::Module[T.anything]]) }
  def requested_constants; end

  sig { returns(T::Array[::Pathname]) }
  def requested_paths; end

  sig do
    type_parameters(:R)
      .params(
        blk: T.proc.params(constant: T::Module[T.anything], rbi: ::RBI::File).returns(T.type_parameter(:R))
      ).returns(T::Array[T.type_parameter(:R)])
  end
  def run(&blk); end

  sig { returns(T::Array[T::Module[T.anything]]) }
  def skipped_constants; end

  private

  sig { void }
  def abort_if_pending_migrations!; end

  sig { params(constants: T::Set[T::Module[T.anything]]).returns(T::Set[T::Module[T.anything]]) }
  def filter_anonymous_constants(constants); end

  sig do
    params(
      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)]
    ).returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)])
  end
  def gather_active_compilers(requested_compilers, excluded_compilers); end

  sig do
    params(
      requested_constants: T::Array[T::Module[T.anything]],
      requested_paths: T::Array[::Pathname],
      skipped_constants: T::Array[T::Module[T.anything]]
    ).returns(T::Set[T::Module[T.anything]])
  end
  def gather_constants(requested_constants, requested_paths, skipped_constants); end

  sig { params(constant: T::Module[T.anything]).returns(T.nilable(::RBI::File)) }
  def rbi_for_constant(constant); end

  sig { params(error: ::String).void }
  def report_error(error); end
end

module Tapioca::EnvHelper
  requires_ancestor { Thor }

  sig { params(options: T::Hash[::Symbol, T.untyped]).void }
  def set_environment(options); end
end

class Tapioca::Error < ::StandardError; end

class Tapioca::Executor
  sig { params(queue: T::Array[T.untyped], number_of_workers: T.nilable(::Integer)).void }
  def initialize(queue, number_of_workers: T.unsafe(nil)); end

  sig do
    type_parameters(:T)
      .params(
        block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T))
      ).returns(T::Array[T.type_parameter(:T)])
  end
  def run_in_parallel(&block); end

  private

  sig { returns(::Integer) }
  def max_processors; end
end

Tapioca::Executor::MINIMUM_ITEMS_PER_WORKER = T.let(T.unsafe(nil), Integer)
module Tapioca::Gem; end

class Tapioca::Gem::ConstNodeAdded < ::Tapioca::Gem::NodeAdded
  sig { params(symbol: ::String, constant: T::Module[T.anything], node: ::RBI::Const).void }
  def initialize(symbol, constant, node); end

  sig { returns(::RBI::Const) }
  def node; end
end

class Tapioca::Gem::ConstantFound < ::Tapioca::Gem::Event
  def initialize(symbol, constant); end

  def constant; end

  sig { returns(::String) }
  def symbol; end
end

class Tapioca::Gem::Event
  abstract!
end

class Tapioca::Gem::ForeignConstantFound < ::Tapioca::Gem::ConstantFound
  sig { params(symbol: ::String, constant: T::Module[T.anything]).void }
  def initialize(symbol, constant); end

  sig { override.returns(T::Module[T.anything]) }
  def constant; end
end

class Tapioca::Gem::ForeignScopeNodeAdded < ::Tapioca::Gem::ScopeNodeAdded; end
module Tapioca::Gem::Listeners; end

class Tapioca::Gem::Listeners::Base
  abstract!

  sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
  def initialize(pipeline); end

  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
  def dispatch(event); end

  private

  sig { params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { params(event: ::Tapioca::Gem::ConstNodeAdded).void }
  def on_const(event); end

  sig { params(event: ::Tapioca::Gem::MethodNodeAdded).void }
  def on_method(event); end

  sig { params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::Documentation < ::Tapioca::Gem::Listeners::Base
  sig { params(pipeline: ::Tapioca::Gem::Pipeline, gem_graph: ::Rubydex::Graph).void }
  def initialize(pipeline, gem_graph); end

  private

  sig { params(name: ::String, sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) }
  def documentation_comments(name, sigs: T.unsafe(nil)); end

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
  def on_const(event); end

  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
  def on_method(event); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end

  sig { params(line: ::String).returns(T::Boolean) }
  def rbs_comment?(line); end
end

Tapioca::Gem::Listeners::Documentation::IGNORED_COMMENTS = T.let(T.unsafe(nil), Array)

class Tapioca::Gem::Listeners::DynamicMixins < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::Runtime::Reflection

  private

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::ForeignConstants < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::Runtime::Reflection

  private

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { params(location: ::String).returns(T::Boolean) }
  def mixed_in_by_gem?(location); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::SorbetHelper
  include ::Tapioca::RBIHelper
  include ::Tapioca::Runtime::Reflection

  private

  sig do
    params(
      tree: ::RBI::Tree,
      module_name: ::String,
      mod: T::Module[T.anything],
      for_visibility: T::Array[::Symbol],
      attached_class: T.nilable(T::Module[T.anything])
    ).void
  end
  def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil), attached_class: T.unsafe(nil)); end

  sig do
    params(
      tree: ::RBI::Tree,
      symbol_name: ::String,
      constant: T::Module[T.anything],
      method: T.nilable(::UnboundMethod),
      visibility: ::RBI::Visibility
    ).void
  end
  def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { params(constant: T::Module[T.anything]).returns(T.nilable(::UnboundMethod)) }
  def initialize_method_for(constant); end

  sig { params(mod: T::Module[T.anything]).returns(T::Hash[::Symbol, T::Array[::Symbol]]) }
  def method_names_by_visibility(mod); end

  sig do
    params(
      attached_class: T.nilable(T::Module[T.anything]),
      method_name: ::Symbol
    ).returns(T.nilable(T::Boolean))
  end
  def method_new_in_abstract_class?(attached_class, method_name); end

  sig { params(method: ::UnboundMethod, constant: T::Module[T.anything]).returns(T::Boolean) }
  def method_owned_by_constant?(method, constant); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end

  sig { params(constant: T::Module[T.anything], method_name: ::String).returns(T::Boolean) }
  def struct_method?(constant, method_name); end
end

class Tapioca::Gem::Listeners::Mixins < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::Runtime::Reflection

  private

  sig do
    params(
      tree: ::RBI::Tree,
      constant: T::Module[T.anything],
      mods: T::Array[T::Module[T.anything]],
      mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
    ).void
  end
  def add_mixins(tree, constant, mods, mixin_type); end

  sig { params(mixin_name: ::String).returns(T::Boolean) }
  def filtered_mixin?(mixin_name); end

  sig { params(constant: T::Module[T.anything]).returns(T::Array[T::Module[T.anything]]) }
  def interesting_ancestors_of(constant); end

  sig do
    params(
      constant: T::Module[T.anything],
      mixin: T::Module[T.anything],
      mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
    ).returns(T::Boolean)
  end
  def mixed_in_by_gem?(constant, mixin, mixin_type); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::RemoveEmptyPayloadScopes < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::Runtime::Reflection

  private

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::SorbetEnums < ::Tapioca::Gem::Listeners::Base
  private

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::SorbetHelpers < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::Runtime::Reflection

  private

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::SorbetProps < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::SorbetHelper
  include ::Tapioca::RBIHelper

  private

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::SorbetRequiredAncestors < ::Tapioca::Gem::Listeners::Base
  private

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::SorbetSignatures < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::Runtime::Reflection
  include ::Tapioca::SorbetHelper
  include ::Tapioca::RBIHelper

  private

  sig { params(signature: T.untyped, parameters: T::Array[[::Symbol, ::String]]).returns(::RBI::Sig) }
  def compile_signature(signature, parameters); end

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
  def on_method(event); end

  sig { params(signature: T.untyped).returns(T::Boolean) }
  def signature_final?(signature); end
end

class Tapioca::Gem::Listeners::SorbetTypeVariables < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::Runtime::Reflection

  private

  sig { params(tree: ::RBI::Tree, constant: T::Module[T.anything]).void }
  def compile_type_variable_declarations(tree, constant); end

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { params(type_variable: ::Tapioca::TypeVariableModule).returns(T.nilable(::RBI::Node)) }
  def node_from_type_variable(type_variable); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::SourceLocation < ::Tapioca::Gem::Listeners::Base
  private

  sig { params(node: ::RBI::NodeWithComments, file: T.nilable(::String), line: T.nilable(::Integer)).void }
  def add_source_location_comment(node, file, line); end

  sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
  def on_const(event); end

  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
  def on_method(event); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::Listeners::Subconstants < ::Tapioca::Gem::Listeners::Base
  include ::Tapioca::Runtime::Reflection

  private

  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
  def ignore?(event); end

  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
  def on_scope(event); end
end

class Tapioca::Gem::MethodNodeAdded < ::Tapioca::Gem::NodeAdded
  sig do
    params(
      symbol: ::String,
      constant: T::Module[T.anything],
      method: ::UnboundMethod,
      node: ::RBI::Method,
      signature: T.untyped,
      parameters: T::Array[[::Symbol, ::String]]
    ).void
  end
  def initialize(symbol, constant, method, node, signature, parameters); end

  sig { returns(::UnboundMethod) }
  def method; end

  sig { returns(::RBI::Method) }
  def node; end

  sig { returns(T::Array[[::Symbol, ::String]]) }
  def parameters; end

  sig { returns(T.untyped) }
  def signature; end
end

class Tapioca::Gem::NodeAdded < ::Tapioca::Gem::Event
  abstract!

  sig { params(symbol: ::String, constant: T::Module[T.anything]).void }
  def initialize(symbol, constant); end

  sig { returns(T::Module[T.anything]) }
  def constant; end

  sig { returns(::String) }
  def symbol; end
end

class Tapioca::Gem::Pipeline
  include ::Tapioca::Runtime::Reflection
  include ::Tapioca::SorbetHelper
  include ::Tapioca::RBIHelper

  sig do
    params(
      gem: ::Tapioca::Gemfile::GemSpec,
      error_handler: T.proc.params(error: ::String).void,
      include_doc: T::Boolean,
      include_loc: T::Boolean
    ).void
  end
  def initialize(gem, error_handler:, include_doc: T.unsafe(nil), include_loc: T.unsafe(nil)); end

  sig { returns(::RBI::Tree) }
  def compile; end

  sig { params(name: T.any(::String, ::Symbol)).returns(T::Boolean) }
  def constant_in_gem?(name); end

  sig { returns(T.proc.params(error: ::String).void) }
  def error_handler; end

  sig { returns(::Tapioca::Gemfile::GemSpec) }
  def gem; end

  sig do
    params(
      method_name: ::Symbol,
      owner: T::Module[T.anything]
    ).returns(::Tapioca::Gem::Pipeline::MethodDefinitionLookupResult)
  end
  def method_definition_in_gem(method_name, owner); end

  sig { params(constant: T::Module[T.anything]).returns(T.nilable(::String)) }
  def name_of(constant); end

  sig { params(symbol: ::String, constant: T::Module[T.anything], node: ::RBI::Const).void }
  def push_const(symbol, constant, node); end

  def push_constant(symbol, constant); end

  sig { params(symbol: ::String, constant: T::Module[T.anything]).void }
  def push_foreign_constant(symbol, constant); end

  sig { params(symbol: ::String, constant: T::Module[T.anything], node: ::RBI::Scope).void }
  def push_foreign_scope(symbol, constant, node); end

  sig do
    params(
      symbol: ::String,
      constant: T::Module[T.anything],
      method: ::UnboundMethod,
      node: ::RBI::Method,
      signature: T.untyped,
      parameters: T::Array[[::Symbol, ::String]]
    ).void
  end
  def push_method(symbol, constant, method, node, signature, parameters); end

  sig { params(symbol: ::String, constant: T::Module[T.anything], node: ::RBI::Scope).void }
  def push_scope(symbol, constant, node); end

  sig { params(symbol: ::String).void }
  def push_symbol(symbol); end

  sig { params(symbol_name: ::String).returns(T::Boolean) }
  def symbol_in_payload?(symbol_name); end

  private

  sig { params(name: ::String).void }
  def add_to_alias_namespace(name); end

  sig { params(name: ::String).returns(T::Boolean) }
  def alias_namespaced?(name); end

  sig { params(name: ::String, constant: T::Module[T.anything]).void }
  def compile_alias(name, constant); end

  def compile_constant(symbol, constant); end

  sig { params(symbol: ::String, constant: T::Module[T.anything]).void }
  def compile_foreign_constant(symbol, constant); end

  sig { params(name: ::String, constant: T::Module[T.anything]).void }
  def compile_module(name, constant); end

  def compile_object(name, value); end

  sig { params(name: ::String, constant: T::Module[T.anything]).returns(::RBI::Scope) }
  def compile_scope(name, constant); end

  sig { params(constant: T::Class[T.anything]).returns(T.nilable(::String)) }
  def compile_superclass(constant); end

  sig { params(constant: T::Module[T.anything], strict: T::Boolean).returns(T::Boolean) }
  def defined_in_gem?(constant, strict: T.unsafe(nil)); end

  sig { params(event: ::Tapioca::Gem::Event).void }
  def dispatch(event); end

  sig { params(constant: T.all(::T::Generic, T::Module[T.anything])).returns(::String) }
  def generic_name_of(constant); end

  sig { params(constant: T::Module[T.anything]).returns(T::Set[::String]) }
  def get_file_candidates(constant); end

  sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
  def load_bootstrap_symbols(gem); end

  sig { params(constant: T::Module[T.anything], class_name: T.nilable(::String)).returns(T.nilable(::String)) }
  def name_of_proxy_target(constant, class_name); end

  sig { returns(::Tapioca::Gem::Event) }
  def next_event; end

  sig { params(event: ::Tapioca::Gem::ConstantFound).void }
  def on_constant(event); end

  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
  def on_node(event); end

  sig { params(event: ::Tapioca::Gem::SymbolFound).void }
  def on_symbol(event); end

  sig { params(name: ::String).void }
  def seen!(name); end

  sig { params(name: ::String).returns(T::Boolean) }
  def seen?(name); end

  sig { params(name: ::String, constant: T::Module[T.anything]).returns(T::Boolean) }
  def skip_alias?(name, constant); end

  def skip_constant?(name, constant); end

  sig { params(name: ::String, constant: T::Module[T.anything]).returns(T::Boolean) }
  def skip_foreign_constant?(name, constant); end

  sig { params(name: ::String, constant: T::Module[T.anything]).returns(T::Boolean) }
  def skip_module?(name, constant); end

  def skip_object?(name, constant); end

  sig { params(name: ::String).returns(T::Boolean) }
  def skip_symbol?(name); end
end

Tapioca::Gem::Pipeline::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)

class Tapioca::Gem::Pipeline::MethodDefinitionLookupResult
  abstract!
end

class Tapioca::Gem::Pipeline::MethodInGemWithLocation < ::Tapioca::Gem::Pipeline::MethodDefinitionLookupResult
  sig { params(location: ::Tapioca::Runtime::SourceLocation).void }
  def initialize(location); end

  sig { returns(::Tapioca::Runtime::SourceLocation) }
  def location; end
end

class Tapioca::Gem::Pipeline::MethodInGemWithoutLocation < ::Tapioca::Gem::Pipeline::MethodDefinitionLookupResult; end
class Tapioca::Gem::Pipeline::MethodNotInGem < ::Tapioca::Gem::Pipeline::MethodDefinitionLookupResult; end
class Tapioca::Gem::Pipeline::MethodUnknown < ::Tapioca::Gem::Pipeline::MethodDefinitionLookupResult; end

class Tapioca::Gem::ScopeNodeAdded < ::Tapioca::Gem::NodeAdded
  sig { params(symbol: ::String, constant: T::Module[T.anything], node: ::RBI::Scope).void }
  def initialize(symbol, constant, node); end

  sig { returns(::RBI::Scope) }
  def node; end
end

class Tapioca::Gem::SymbolFound < ::Tapioca::Gem::Event
  sig { params(symbol: ::String).void }
  def initialize(symbol); end

  sig { returns(::String) }
  def symbol; end
end

module Tapioca::GemHelper
  sig { params(app_dir: T.any(::Pathname, ::String), full_gem_path: ::String).returns(T::Boolean) }
  def gem_in_app_dir?(app_dir, full_gem_path); end

  sig { params(full_gem_path: ::String).returns(T::Boolean) }
  def gem_in_bundle_path?(full_gem_path); end

  sig { params(full_gem_path: ::String).returns(T::Boolean) }
  def gem_in_ruby_path?(full_gem_path); end

  sig { params(path: T.any(::Pathname, ::String)).returns(::String) }
  def to_realpath(path); end

  private

  sig { params(path: T.any(::Pathname, ::String), dir: T.any(::Pathname, ::String)).returns(T::Boolean) }
  def path_in_dir?(path, dir); end
end

class Tapioca::GemInfo < ::T::Struct
  const :name, ::String
  const :version, ::Gem::Version

  class << self
    sig { params(spec: T.any(::Bundler::StubSpecification, ::Gem::Specification)).returns(::Tapioca::GemInfo) }
    def from_spec(spec); end
  end
end

class Tapioca::Gemfile
  sig { params(excluded_gems: T::Array[::String]).void }
  def initialize(excluded_gems); end

  sig { returns(::Bundler::Definition) }
  def definition; end

  sig { returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
  def dependencies; end

  sig { params(gem_name: ::String).returns(T.nilable(::Tapioca::Gemfile::GemSpec)) }
  def gem(gem_name); end

  sig { returns(T::Array[::String]) }
  def missing_specs; end

  sig { void }
  def require_bundle; end

  private

  sig { returns(::String) }
  def dir; end

  sig { returns(::File) }
  def gemfile; end

  sig { returns(T::Array[::Symbol]) }
  def groups; end

  sig { returns([T::Array[::Tapioca::Gemfile::GemSpec], T::Array[::String]]) }
  def load_dependencies; end

  def lockfile; end

  sig { returns([T::Enumerable[T.any(::Bundler::StubSpecification, ::Gem::Specification)], T::Array[::String]]) }
  def materialize_deps; end

  sig { returns(::Bundler::Runtime) }
  def runtime; end
end

class Tapioca::Gemfile::GemSpec
  include ::Tapioca::GemHelper

  sig { params(spec: T.any(::Bundler::StubSpecification, ::Gem::Specification)).void }
  def initialize(spec); end

  sig { params(other: ::BasicObject).returns(T::Boolean) }
  def ==(other); end

  sig { params(path: ::String).returns(T::Boolean) }
  def contains_path?(path); end

  sig { returns(T::Array[::Gem::Dependency]) }
  def dependencies; end

  sig { returns(T::Boolean) }
  def export_rbi_files?; end

  sig { returns(T::Array[::String]) }
  def exported_rbi_files; end

  sig { returns(::RBI::MergeTree) }
  def exported_rbi_tree; end

  sig { returns(T::Array[::Pathname]) }
  def files; end

  sig { returns(::String) }
  def full_gem_path; end

  sig { params(gemfile_dir: ::String).returns(T::Boolean) }
  def ignore?(gemfile_dir); end

  sig { returns(::String) }
  def name; end

  sig { returns(::String) }
  def rbi_file_name; end

  sig { params(file: ::Pathname).returns(::Pathname) }
  def relative_path_for(file); end

  def version; end

  private

  sig { returns(T::Array[::Pathname]) }
  def collect_files; end

  sig { returns(T.nilable(T::Boolean)) }
  def default_gem?; end

  sig { returns(T::Boolean) }
  def gem_ignored?; end

  sig { params(path: ::String).returns(T::Boolean) }
  def has_parent_gemspec?(path); end

  sig { returns(::Regexp) }
  def require_paths_prefix_matcher; end

  sig { params(file: ::String).returns(::Pathname) }
  def resolve_to_ruby_lib_dir(file); end

  sig { returns(::String) }
  def version_string; end

  class << self
    sig { returns(T::Hash[::String, ::Tapioca::Gemfile::GemSpec]) }
    def spec_lookup_by_file_path; end
  end
end

Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
Tapioca::Gemfile::Spec = T.type_alias { T.any(::Bundler::StubSpecification, ::Gem::Specification) }
module Tapioca::Helpers; end

class Tapioca::Helpers::PackageURL
  def initialize(type:, name:, namespace: T.unsafe(nil), version: T.unsafe(nil), qualifiers: T.unsafe(nil), subpath: T.unsafe(nil)); end

  def deconstruct; end
  def deconstruct_keys(_keys); end
  def name; end
  def namespace; end
  def qualifiers; end
  def scheme; end
  def subpath; end
  def to_h; end
  def to_s; end
  def type; end
  def version; end

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

class Tapioca::Helpers::PackageURL::InvalidPackageURL < ::ArgumentError; end
Tapioca::LIB_ROOT_DIR = T.let(T.unsafe(nil), String)
module Tapioca::Loaders; end

class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader
  sig do
    params(
      tapioca_path: ::String,
      eager_load: T::Boolean,
      app_root: ::String,
      halt_upon_load_error: T::Boolean
    ).void
  end
  def initialize(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end

  sig { override.void }
  def load; end

  sig { void }
  def load_dsl_extensions_and_compilers; end

  sig { void }
  def reload_custom_compilers; end

  protected

  sig { void }
  def load_application; end

  sig { void }
  def load_dsl_compilers; end

  sig { void }
  def load_dsl_extensions; end

  private

  sig { void }
  def load_custom_dsl_compilers; end

  class << self
    sig do
      params(
        tapioca_path: ::String,
        eager_load: T::Boolean,
        app_root: ::String,
        halt_upon_load_error: T::Boolean
      ).void
    end
    def load_application(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
  end
end

class Tapioca::Loaders::Gem < ::Tapioca::Loaders::Loader
  sig do
    params(
      bundle: ::Tapioca::Gemfile,
      prerequire: T.nilable(::String),
      postrequire: ::String,
      default_command: ::String,
      halt_upon_load_error: T::Boolean
    ).void
  end
  def initialize(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end

  sig { override.void }
  def load; end

  protected

  sig { params(file: ::String, error: ::LoadError).void }
  def explain_failed_require(file, error); end

  sig { void }
  def require_gem_file; end

  class << self
    sig do
      params(
        bundle: ::Tapioca::Gemfile,
        prerequire: T.nilable(::String),
        postrequire: ::String,
        default_command: ::String,
        halt_upon_load_error: T::Boolean
      ).void
    end
    def load_application(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end
  end
end

class Tapioca::Loaders::Loader
  include ::Thor::Base
  include ::Thor::Invocation
  include ::Thor::Shell
  include ::Tapioca::CliHelper
  include ::Tapioca::GemHelper
  extend ::Thor::Base::ClassMethods
  extend ::Thor::Invocation::ClassMethods

  abstract!

  sig { abstract.void }
  def load; end

  private

  def eager_load_paths(engine); end

  sig { void }
  def eager_load_rails_app; end

  def engines; end

  sig do
    params(
      gemfile: ::Tapioca::Gemfile,
      initialize_file: T.nilable(::String),
      require_file: T.nilable(::String),
      halt_upon_load_error: T::Boolean
    ).void
  end
  def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error); end

  sig { void }
  def load_engines_in_classic_mode; end

  sig { void }
  def load_engines_in_zeitwerk_mode; end

  sig do
    params(
      environment_load: T::Boolean,
      eager_load: T::Boolean,
      app_root: ::String,
      halt_upon_load_error: T::Boolean
    ).void
  end
  def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end

  sig { void }
  def load_rails_engines; end

  sig { params(file: T.nilable(::String)).void }
  def require_helper(file); end

  def run_initializers; end

  sig { params(path: ::String).void }
  def safe_require(path); end

  sig { params(blk: T.proc.void).void }
  def with_rails_application(&blk); end

  sig { returns(T::Boolean) }
  def zeitwerk_mode?; end
end

module Tapioca::RBIFilesHelper
  requires_ancestor { Tapioca::SorbetHelper }
  requires_ancestor { Thor::Shell }

  sig do
    params(
      index: ::RBI::Index,
      shim_rbi_dir: ::String,
      todo_rbi_file: ::String
    ).returns(T::Hash[::String, T::Array[::RBI::Node]])
  end
  def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:); end

  sig { params(index: ::RBI::Index, kind: ::String, file: ::String).void }
  def index_rbi(index, kind, file); end

  sig { params(index: ::RBI::Index, kind: ::String, dir: ::String, number_of_workers: T.nilable(::Integer)).void }
  def index_rbis(index, kind, dir, number_of_workers:); end

  sig { params(loc: ::RBI::Loc, path_prefix: T.nilable(::String)).returns(::String) }
  def location_to_payload_url(loc, path_prefix:); end

  sig do
    params(
      command: ::String,
      gem_dir: ::String,
      dsl_dir: ::String,
      auto_strictness: T::Boolean,
      gems: T::Array[::Tapioca::Gemfile::GemSpec],
      compilers: T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]
    ).void
  end
  def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: T.unsafe(nil), compilers: T.unsafe(nil)); end

  private

  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)]) }
  def extract_methods_and_attrs(nodes); end

  sig do
    params(
      nodes: T::Array[::RBI::Node],
      shim_rbi_dir: ::String,
      todo_rbi_file: ::String
    ).returns(T::Array[::RBI::Node])
  end
  def extract_shims_and_todos(nodes, shim_rbi_dir:, todo_rbi_file:); end

  sig { params(path: ::String).returns(::String) }
  def gem_name_from_rbi_path(path); end

  sig { params(nodes: T::Array[::RBI::Node], shims_or_todos: T::Array[::RBI::Node]).returns(T::Boolean) }
  def has_duplicated_methods_and_attrs?(nodes, shims_or_todos); end

  sig { params(shims_or_todos: T::Array[::RBI::Node]).returns(T::Boolean) }
  def has_duplicated_mixins?(shims_or_todos); end

  sig { params(all_nodes: T::Array[::RBI::Node], shims_or_todos: T::Array[::RBI::Node]).returns(T::Boolean) }
  def has_duplicated_scopes?(all_nodes, shims_or_todos); end

  sig { params(index: ::RBI::Index, files: T::Array[::String], number_of_workers: T.nilable(::Integer)).void }
  def parse_and_index_files(index, files, number_of_workers:); end

  sig { params(nodes: T::Array[::RBI::Node], shim_rbi_dir: ::String, todo_rbi_file: ::String).returns(T::Boolean) }
  def shims_or_todos_have_duplicates?(nodes, shim_rbi_dir:, todo_rbi_file:); end

  sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error], gem_dir: ::String).void }
  def update_gem_rbis_strictnesses(errors, gem_dir); end
end

class Tapioca::RBIFormatter < ::RBI::Formatter
  sig { params(file: ::RBI::File).void }
  def write_empty_body_comment!(file); end

  sig { params(file: ::RBI::File, command: ::String, reason: T.nilable(::String)).void }
  def write_header!(file, command, reason: T.unsafe(nil)); end
end

module Tapioca::RBIHelper
  include ::Tapioca::SorbetHelper
  extend ::Tapioca::SorbetHelper
  extend ::Tapioca::RBIHelper

  sig { params(type: ::String).returns(::String) }
  def as_nilable_type(type); end

  sig { params(type: ::String).returns(::String) }
  def as_non_nilable_type(type); end

  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
  def create_block_param(name, type:); end

  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
  def create_kw_opt_param(name, type:, default:); end

  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
  def create_kw_param(name, type:); end

  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
  def create_kw_rest_param(name, type:); end

  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
  def create_opt_param(name, type:, default:); end

  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
  def create_param(name, type:); end

  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
  def create_rest_param(name, type:); end

  sig { params(param: ::RBI::Param, type: ::String).returns(::RBI::TypedParam) }
  def create_typed_param(param, type); end

  sig { params(type_strings: T::Array[::String]).returns(T::Array[::String]) }
  def extract_type_parameters(type_strings); end

  sig { params(sig_string: ::String).returns(::String) }
  def sanitize_signature_types(sig_string); end

  sig { params(name: ::String).returns(T::Boolean) }
  def valid_method_name?(name); end

  sig { params(name: ::String).returns(T::Boolean) }
  def valid_parameter_name?(name); end

  class << self
    sig do
      params(
        type: ::String,
        variance: ::Symbol,
        fixed: T.nilable(::String),
        upper: T.nilable(::String),
        lower: T.nilable(::String)
      ).returns(::String)
    end
    def serialize_type_variable(type, variance, fixed, upper, lower); end
  end
end

Tapioca::RBIHelper::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
module Tapioca::RBS; end

module Tapioca::RBS::BootsnapGuard
  sig { params(_kwargs: T.untyped).void }
  def setup(**_kwargs); end
end

class Tapioca::RBS::HostBootsnapSetupError < ::StandardError; end

class Tapioca::RepoIndex
  sig { void }
  def initialize; end

  sig { params(gem_name: ::String).void }
  def <<(gem_name); end

  sig { returns(T::Enumerable[::String]) }
  def gems; end

  sig { params(gem_name: ::String).returns(T::Boolean) }
  def has_gem?(gem_name); end

  class << self
    sig { params(hash: T::Hash[::String, T::Hash[T.untyped, T.untyped]]).returns(::Tapioca::RepoIndex) }
    def from_hash(hash); end

    sig { params(json: ::String).returns(::Tapioca::RepoIndex) }
    def from_json(json); end
  end
end

module Tapioca::Runtime
  class << self
    def silence_warnings(&blk); end
    def with_disabled_exits(&block); end
  end
end

class Tapioca::Runtime::DynamicMixinCompiler
  include ::Tapioca::Runtime::Reflection

  def initialize(constant); end

  def class_attribute_predicates; end
  def class_attribute_readers; end
  def class_attribute_writers; end
  def compile_class_attributes(tree); end
  def compile_mixes_in_class_methods(tree); end
  def dynamic_extends; end
  def dynamic_includes; end
  def empty_attributes?; end
  def filtered_mixin?(qualified_mixin_name); end
  def instance_attribute_predicates; end
  def instance_attribute_readers; end
  def instance_attribute_writers; end
  def module_included_by_another_dynamic_extend?(mod, dynamic_extends); end
end

module Tapioca::Runtime::GenericTypeRegistry
  class << self
    def generic_type_instance?(instance); end
    def lookup_type_variables(constant); end
    def register_type(constant, types); end
    def register_type_variable(constant, type_variable); end

    private

    def create_generic_type(constant, name); end
    def create_safe_subclass(constant); end
  end
end

class Tapioca::Runtime::GenericTypeRegistry::GenericType < ::T::Types::Simple
  def initialize(raw_type, underlying_type); end

  def valid?(obj); end
end

Tapioca::Runtime::NOOP_METHOD = T.let(T.unsafe(nil), Proc)

module Tapioca::Runtime::Reflection
  extend ::Tapioca::Runtime::Reflection

  def abstract_type_of(constant); end
  def ancestors_of(constant); end
  def are_equal?(object, other); end
  def attached_class_of(singleton_class); end
  def class_of(object); end
  def const_source_location(constant_name); end
  def constant_defined?(constant); end
  def constantize(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end
  def constants_of(constant); end
  def descendants_of(klass); end
  def file_candidates_for(constant); end
  def final_module?(constant); end
  def inherited_ancestors_of(constant); end
  def method_of(constant, method); end
  def name_of(constant); end
  def name_of_type(type); end
  def object_id_of(object); end
  def private_instance_methods_of(constant); end
  def protected_instance_methods_of(constant); end
  def public_instance_methods_of(constant); end
  def qualified_name_of(constant); end
  def resolve_loc(locations); end
  def sealed_module?(constant); end
  def signature_of(method); end
  def signature_of!(method); end
  def singleton_class_of(constant); end
  def superclass_of(constant); end

  private

  def child_module_for_parent_with_name(parent, name); end
  def has_aliased_namespace?(name); end
  def method_defined_by_forwardable_module?(method); end
  def methods_for(constant); end
  def relevant_methods_for(constant); end
end

Tapioca::Runtime::Reflection::ANCESTORS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::CONSTANTS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::EQUAL_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::OBJECT_ID_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::PRIVATE_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::PROTECTED_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::PUBLIC_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::REQUIRED_FROM_LABELS = T.let(T.unsafe(nil), Array)
Tapioca::Runtime::Reflection::SINGLETON_CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
Tapioca::Runtime::Reflection::SUPERCLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
class Tapioca::Runtime::Reflection::SignatureBlockError < ::Tapioca::Error; end

class Tapioca::Runtime::SourceLocation
  def initialize(file:, line:); end

  def file; end
  def line; end

  class << self
    def from_loc(loc); end

    private

    def new(*_arg0); end
  end
end

Tapioca::Runtime::SourceLocation::EVAL_SOURCE_FILE_PATTERN = T.let(T.unsafe(nil), Regexp)

module Tapioca::Runtime::Trackers
  class << self
    def disable_all!; end
    def register_tracker(tracker); end
    def with_trackers_enabled(&blk); end
  end
end

module Tapioca::Runtime::Trackers::Autoload
  extend ::Tapioca::Runtime::Trackers::Tracker

  class << self
    def eager_load_all!; end
    def register(constant_name); end
  end
end

module Tapioca::Runtime::Trackers::ConstantDefinition
  extend ::Tapioca::Runtime::Trackers::Tracker
  extend ::Tapioca::Runtime::Reflection

  class << self
    def build_source_location(tp, locations); end
    def disable!; end
    def files_for(klass); end
    def locations_for(klass); end
    def register(constant, loc); end
    def register_cname(cname, namespace, locations); end
  end
end

module Tapioca::Runtime::Trackers::MethodDefinition
  extend ::Tapioca::Runtime::Trackers::Tracker

  class << self
    def method_definitions_for(method_name, owner); end
    def register(method_name, owner, locations); end

    private

    def registrations_for(method_name, owner); end
  end
end

module Tapioca::Runtime::Trackers::Mixin
  extend ::Tapioca::Runtime::Trackers::Tracker

  class << self
    def constants_with_mixin(mixin); end
    def mixin_location(mixin, mixin_type, constant); end
    def register(constant, mixin, mixin_type); end
    def resolve_to_attached_class(constant, mixin, mixin_type); end
    def with_disabled_registration(&block); end

    private

    def find_or_initialize_mixin_lookup(mixin); end
    def register_with_location(constant, mixin, mixin_type, location); end
  end
end

class Tapioca::Runtime::Trackers::Mixin::Type < ::T::Enum
  enums do
    Extend = new
    Include = new
    Prepend = new
  end
end

module Tapioca::Runtime::Trackers::RequiredAncestor
  extend ::Tapioca::Runtime::Trackers::Tracker

  class << self
    def register(requiring, block); end
    def required_ancestors_blocks_by(mod); end
    def required_ancestors_by(mod); end
  end
end

module Tapioca::Runtime::Trackers::Tracker
  def disable!; end
  def enabled?; end
  def with_disabled_tracker(&block); end

  class << self
    def extended(base); end
  end
end

Tapioca::SORBET_CONFIG_FILE = T.let(T.unsafe(nil), String)
Tapioca::SORBET_DIR = T.let(T.unsafe(nil), String)

module Tapioca::SorbetHelper
  sig { params(sorbet_args: ::String).returns(::Spoom::ExecResult) }
  def sorbet(*sorbet_args); end

  sig { returns(::String) }
  def sorbet_path; end

  sig { params(feature: ::Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) }
  def sorbet_supports?(feature, version: T.unsafe(nil)); end

  sig { params(source: ::String, rbi_mode: T::Boolean, on_failure: T.proc.params(stderr: ::String).void).void }
  def sorbet_syntax_check!(source, rbi_mode:, &on_failure); end
end

Tapioca::SorbetHelper::FEATURE_REQUIREMENTS = T.let(T.unsafe(nil), Hash)
Tapioca::SorbetHelper::SORBET_BIN = T.let(T.unsafe(nil), Pathname)
Tapioca::SorbetHelper::SORBET_EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String)
Tapioca::SorbetHelper::SORBET_GEM_SPEC = T.let(T.unsafe(nil), Gem::Specification)
Tapioca::SorbetHelper::SORBET_PAYLOAD_URL = T.let(T.unsafe(nil), String)
Tapioca::SorbetHelper::SPOOM_CONTEXT = T.let(T.unsafe(nil), Spoom::Context)
module Tapioca::Static; end

class Tapioca::Static::RequiresCompiler
  sig { params(sorbet_path: ::String).void }
  def initialize(sorbet_path); end

  sig { returns(::String) }
  def compile; end

  private

  sig { params(config: ::Spoom::Sorbet::Config).returns(T::Array[::String]) }
  def collect_files(config); end

  sig { params(file_path: ::String).returns(T::Enumerable[::String]) }
  def collect_requires(file_path); end

  sig { params(config: ::Spoom::Sorbet::Config, file_path: ::Pathname).returns(T::Boolean) }
  def file_ignored_by_sorbet?(config, file_path); end

  sig { params(path: ::Pathname).returns(T::Array[::String]) }
  def path_parts(path); end
end

module Tapioca::Static::SymbolLoader
  extend ::Tapioca::SorbetHelper
  extend ::Tapioca::Runtime::Reflection

  class << self
    sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
    def engine_symbols(gem); end

    sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
    def gem_symbols(gem); end

    sig { params(paths: T::Array[::Pathname]).returns(::Rubydex::Graph) }
    def graph_from_paths(paths); end

    sig { returns(T::Set[::String]) }
    def payload_symbols; end

    sig { params(paths: T::Array[::Pathname]).returns(T::Set[::String]) }
    def symbols_from_paths(paths); end

    private

    def engines; end

    sig { params(input: ::String, table_type: ::String).returns(::String) }
    def symbol_table_json_from(input, table_type: T.unsafe(nil)); end
  end
end

class Tapioca::Static::SymbolTableParser
  sig { void }
  def initialize; end

  sig { params(name: ::String).returns(::String) }
  def fully_qualified_name(name); end

  sig { params(object: T::Hash[::String, T.untyped]).void }
  def parse_object(object); end

  sig { returns(T::Set[::String]) }
  def symbols; end

  class << self
    sig { params(json_string: ::String).returns(T::Set[::String]) }
    def parse_json(json_string); end
  end
end

Tapioca::Static::SymbolTableParser::SKIP_PARSE_KINDS = T.let(T.unsafe(nil), Array)
Tapioca::TAPIOCA_CONFIG_FILE = T.let(T.unsafe(nil), String)
Tapioca::TAPIOCA_DIR = T.let(T.unsafe(nil), String)

class Tapioca::TypeVariable < ::T::Types::TypeVariable
  def initialize(name, variance); end

  def name; end
end

class Tapioca::TypeVariableModule < ::Module
  def initialize(context, type, variance, bounds_proc); end

  def coerce_to_type_variable; end
  def fixed?; end
  def name; end
  def serialize; end
  def type; end

  private

  def bounds; end
end

Tapioca::TypeVariableModule::DEFAULT_BOUNDS_PROC = T.let(T.unsafe(nil), Proc)

class Tapioca::TypeVariableModule::Type < ::T::Enum
  enums do
    HasAttachedClass = new
    Member = new
    Template = new
  end
end

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