diff --git a/.github/workflows/sorbet.yml b/.github/workflows/sorbet.yml
index 6a7b0fff1983f..a08a8bfab077c 100644
--- a/.github/workflows/sorbet.yml
+++ b/.github/workflows/sorbet.yml
@@ -47,17 +47,20 @@ jobs:
         id: update
         working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
         run: |
-          git fetch origin
+          if [[ "${GITHUB_EVENT_NAME}" != "pull_request" ]]
+          then
+            git fetch origin
 
-          BRANCH="sorbet-files-update"
-          echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT"
+            BRANCH="sorbet-files-update"
+            echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT"
 
-          if git ls-remote --exit-code --heads origin "${BRANCH}"
-          then
-            git checkout "${BRANCH}"
-            git checkout "Library/Homebrew/sorbet"
-          else
-            git checkout --no-track -B "${BRANCH}" origin/master
+            if git ls-remote --exit-code --heads origin "${BRANCH}"
+            then
+              git checkout "${BRANCH}"
+              git checkout "Library/Homebrew/sorbet"
+            else
+              git checkout --no-track -B "${BRANCH}" origin/master
+            fi
           fi
 
           brew typecheck --update --suggest-typed
diff --git a/Library/Homebrew/dev-cmd/typecheck.rb b/Library/Homebrew/dev-cmd/typecheck.rb
index e714c240e0055..7f50f2d03ed77 100644
--- a/Library/Homebrew/dev-cmd/typecheck.rb
+++ b/Library/Homebrew/dev-cmd/typecheck.rb
@@ -63,7 +63,8 @@ def self.typecheck
         ohai "Updating Tapioca RBI files..."
         safe_system "bundle", "exec", "tapioca", "gem", *tapioca_args
         safe_system "bundle", "exec", "parlour"
-        safe_system "bundle", "exec", "srb", "rbi", "hidden-definitions"
+        safe_system({ "RUBYLIB" => "#{HOMEBREW_LIBRARY_PATH}/sorbet/hidden_definitions_hacks" },
+                    "bundle", "exec", "srb", "rbi", "hidden-definitions")
         safe_system "bundle", "exec", "tapioca", "todo"
 
         if args.suggest_typed?
diff --git a/Library/Homebrew/sorbet/hidden_definitions_hacks/webrick.rb b/Library/Homebrew/sorbet/hidden_definitions_hacks/webrick.rb
new file mode 100644
index 0000000000000..e8251a00ec0db
--- /dev/null
+++ b/Library/Homebrew/sorbet/hidden_definitions_hacks/webrick.rb
@@ -0,0 +1,4 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file intentionally left blank
diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index 4024e6d520121..bed3a6b8c05ee 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -4,7 +4,7 @@
 # typed: autogenerated
 
 class AbstractCoreTap
-  def initialize(*args, &blk); end
+  def initialize(*args, **arg, &blk); end
 end
 
 class AbstractCoreTap
@@ -16,12 +16,24 @@ class AbstractDownloadStrategy
   include ::FileUtils::StreamUtils_
 end
 
+class ActiveSupport::Callbacks::Filters::Environment
+  def self.keyword_init?(); end
+end
+
 class ActiveSupport::Deprecation
-  def self.deprecation_warning(*args, &block); end
+  def self.deprecation_warning(*arg, **arg1, &arg2); end
+
+  def self.initialize(*arg, **arg1, &arg2); end
+
+  def self.warn(*arg, **arg1, &arg2); end
+end
 
-  def self.initialize(*args, &block); end
+class ActiveSupport::ExecutionWrapper::CompleteHook
+  def self.keyword_init?(); end
+end
 
-  def self.warn(*args, &block); end
+class ActiveSupport::ExecutionWrapper::RunHook
+  def self.keyword_init?(); end
 end
 
 module ActiveSupport::ForkTracker::CoreExtPrivate
@@ -35,6 +47,10 @@ end
 class Array
   def abbrev(pattern=T.unsafe(nil)); end
 
+  def deconstruct(); end
+
+  def intersect?(arg); end
+
   def shelljoin(); end
 
   def to_default_s(); end
@@ -82,6 +98,8 @@ end
 
 class Benchmark::Tms
   def to_a(); end
+
+  def to_h(); end
 end
 
 module Benchmark
@@ -91,23 +109,19 @@ end
 class BigDecimal
   def clone(); end
 
-  def to_digits(); end
-end
+  def n_significant_digits(); end
 
-module BigDecimal::Deprecation
-  def new(*args, **kwargs); end
-end
+  def precision(); end
+
+  def precision_scale(); end
 
-module BigDecimal::Deprecation
+  def scale(); end
+
+  def to_digits(); end
 end
 
 class BigDecimal
-  extend ::BigDecimal::Deprecation
-  def self.inherited(subclass); end
-
   def self.interpret_loosely(arg); end
-
-  def self.new(*arg); end
 end
 
 class Binding
@@ -473,6 +487,8 @@ end
 class Bundler::Fetcher::CompactIndex::ClientFetcher
   def self.[](*arg); end
 
+  def self.keyword_init?(); end
+
   def self.members(); end
 end
 
@@ -1211,6 +1227,10 @@ end
 class Bundler::Settings::Mirrors
 end
 
+class Bundler::Settings::Path
+  def self.keyword_init?(); end
+end
+
 class Bundler::Settings::Validator
 end
 
@@ -1876,6 +1896,8 @@ class Bundler::Thor::CoreExt::HashWithIndifferentAccess
 
   def delete(key); end
 
+  def except(*keys); end
+
   def fetch(key, *args); end
 
   def initialize(hash=T.unsafe(nil)); end
@@ -3078,6 +3100,22 @@ module Bundler
   def self.unbundled_system(*args); end
 end
 
+class CGI
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class CGI::Cookie
+  DOMAIN_VALUE_RE = ::T.let(nil, ::T.untyped)
+  PATH_VALUE_RE = ::T.let(nil, ::T.untyped)
+  TOKEN_RE = ::T.let(nil, ::T.untyped)
+end
+
+module CGI::Escape
+  def escapeURIComponent(arg); end
+
+  def unescapeURIComponent(*arg); end
+end
+
 module CGI::HtmlExtension
   def a(href=T.unsafe(nil)); end
 
@@ -3127,6 +3165,12 @@ end
 module CGI::HtmlExtension
 end
 
+module CGI::Util
+  def escapeURIComponent(arg); end
+
+  def unescapeURIComponent(*arg); end
+end
+
 module Cachable
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -3143,7 +3187,7 @@ module Cask::Cache
 end
 
 class Cask::CaskLoader::AbstractContentLoader
-  def initialize(*args, &blk); end
+  def initialize(*args, **arg, &blk); end
 end
 
 class Cask::CaskLoader::AbstractContentLoader
@@ -3246,6 +3290,10 @@ class Cask::DSL::Caveats
   def zsh_path_helper(*args); end
 end
 
+class Cask::DSL::ConflictsWith
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
 class Cask::DSL::Version
   def dots_to_hyphens(); end
 
@@ -3290,10 +3338,34 @@ class Class
   def any_instance(); end
 end
 
+class Complex
+  def to_d(*args); end
+end
+
+class Concurrent::CRubySet
+  def join(*args); end
+end
+
 class Concurrent::RubyThreadPoolExecutor
   DEFAULT_SYNCHRONOUS = ::T.let(nil, ::T.untyped)
 end
 
+class Concurrent::SerializedExecution::Job
+  def self.keyword_init?(); end
+end
+
+class Concurrent::SerializedExecutionDelegator
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::SynchronizedDelegator
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::Transaction::OpenEntry
+  def self.keyword_init?(); end
+end
+
 module CopHelper
   def _investigate(cop, processed_source); end
 
@@ -3320,6 +3392,8 @@ class Date
 
   def default_inspect(); end
 
+  def infinite?(); end
+
   def minus_without_duration(arg); end
 
   def plus_without_duration(arg); end
@@ -3331,8 +3405,18 @@ class Date::Infinity
   def initialize(d=T.unsafe(nil)); end
 end
 
+class DateTime
+  def self.new(*arg); end
+end
+
 class Delegator
   include ::ActiveSupport::Tryable
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Dependencies
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
 end
 
 class Dependencies
@@ -3491,12 +3575,20 @@ module DidYouMean
   def self.spell_checkers(); end
 end
 
+module Digest
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
 class Dir
   def children(); end
 
   def each_child(); end
 end
 
+module Dir::Tmpname
+  UNUSABLE_CHARS = ::T.let(nil, ::T.untyped)
+end
+
 class Dir
   def self.exists?(arg); end
 end
@@ -3506,6 +3598,10 @@ class Downloadable
   extend ::T::InterfaceWrapper::Helpers
 end
 
+class ELFTools::LazyArray
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
 class ELFTools::Structs::ELF32_PhdrBe
 end
 
@@ -3639,6 +3735,9 @@ end
 
 class Encoding
   def _dump(*arg); end
+  CESU_8 = ::T.let(nil, ::T.untyped)
+  CP720 = ::T.let(nil, ::T.untyped)
+  IBM720 = ::T.let(nil, ::T.untyped)
 end
 
 class Encoding::Converter
@@ -3651,6 +3750,7 @@ end
 
 module Enumerable
   include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+  def compact(); end
 end
 
 class Enumerator
@@ -3688,6 +3788,13 @@ class Enumerator::Generator
   def initialize(*arg); end
 end
 
+class Enumerator::Producer
+  def each(&blk); end
+end
+
+class Enumerator::Producer
+end
+
 class Errno::EAUTH
   Errno = ::T.let(nil, ::T.untyped)
 end
@@ -3723,6 +3830,8 @@ end
 class Errno::EBADRPC
 end
 
+Errno::ECAPMODE = Errno::NOERROR
+
 Errno::EDEADLOCK = Errno::NOERROR
 
 class Errno::EDEVERR
@@ -3743,6 +3852,13 @@ end
 
 Errno::EIPSEC = Errno::NOERROR
 
+class Errno::ELAST
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ELAST
+end
+
 class Errno::ENEEDAUTH
   Errno = ::T.let(nil, ::T.untyped)
 end
@@ -3764,6 +3880,8 @@ end
 class Errno::ENOPOLICY
 end
 
+Errno::ENOTCAPABLE = Errno::NOERROR
+
 class Errno::ENOTSUP
   Errno = ::T.let(nil, ::T.untyped)
 end
@@ -3806,12 +3924,7 @@ end
 class Errno::EPWROFF
 end
 
-class Errno::EQFULL
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EQFULL
-end
+Errno::EQFULL = Errno::ELAST
 
 class Errno::ERPCMISMATCH
   Errno = ::T.let(nil, ::T.untyped)
@@ -3827,6 +3940,10 @@ end
 class Errno::ESHLIBVERS
 end
 
+module Etc
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
 class Etc::Group
   def gid(); end
 
@@ -3851,6 +3968,8 @@ class Etc::Group
 
   def self.each(&blk); end
 
+  def self.keyword_init?(); end
+
   def self.members(); end
 end
 
@@ -3890,6 +4009,8 @@ class Etc::Passwd
 
   def self.each(&blk); end
 
+  def self.keyword_init?(); end
+
   def self.members(); end
 end
 
@@ -3901,49 +4022,274 @@ class Exception
   def self.json_create(object); end
 end
 
-module Exception2MessageMapper
-  def bind(cl); end
+class ExitCalledError
+end
+
+class ExitCalledError
+end
+
+class Fiber
+  def backtrace(*arg); end
+
+  def backtrace_locations(*arg); end
+
+  def blocking?(); end
+
+  def initialize(*arg); end
+
+  def transfer(*arg); end
+end
+
+class Fiber
+  def self.blocking?(); end
+
+  def self.current(); end
+
+  def self.current_scheduler(); end
+
+  def self.schedule(*arg); end
+
+  def self.scheduler(); end
+
+  def self.set_scheduler(arg); end
+end
+
+module Fiddle
+  ALIGN_INT16_T = ::T.let(nil, ::T.untyped)
+  ALIGN_INT32_T = ::T.let(nil, ::T.untyped)
+  ALIGN_INT64_T = ::T.let(nil, ::T.untyped)
+  ALIGN_INT8_T = ::T.let(nil, ::T.untyped)
+  NULL = ::T.let(nil, ::T.untyped)
+  RTLD_GLOBAL = ::T.let(nil, ::T.untyped)
+  RTLD_LAZY = ::T.let(nil, ::T.untyped)
+  RTLD_NOW = ::T.let(nil, ::T.untyped)
+  SIZEOF_CONST_STRING = ::T.let(nil, ::T.untyped)
+  SIZEOF_INT16_T = ::T.let(nil, ::T.untyped)
+  SIZEOF_INT32_T = ::T.let(nil, ::T.untyped)
+  SIZEOF_INT64_T = ::T.let(nil, ::T.untyped)
+  SIZEOF_INT8_T = ::T.let(nil, ::T.untyped)
+  TYPE_CONST_STRING = ::T.let(nil, ::T.untyped)
+  TYPE_INT16_T = ::T.let(nil, ::T.untyped)
+  TYPE_INT32_T = ::T.let(nil, ::T.untyped)
+  TYPE_INT64_T = ::T.let(nil, ::T.untyped)
+  TYPE_INT8_T = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+  WINDOWS = ::T.let(nil, ::T.untyped)
+end
+
+class Fiddle::CStruct
+  include ::Enumerable
+  def each(&blk); end
+
+  def each_pair(); end
+
+  def replace(another); end
+
+  def to_h(); end
 end
 
-Exception2MessageMapper::E2MM = Exception2MessageMapper
+class Fiddle::CStruct
+  def self.entity_class(); end
 
-class Exception2MessageMapper::ErrNotRegisteredException
+  def self.offsetof(name, members, types); end
 end
 
-class Exception2MessageMapper::ErrNotRegisteredException
+module Fiddle::CStructBuilder
 end
 
-module Exception2MessageMapper
-  def self.Fail(klass=T.unsafe(nil), err=T.unsafe(nil), *rest); end
+module Fiddle::CStructBuilder
+  def self.create(klass, types, members); end
+end
 
-  def self.Raise(klass=T.unsafe(nil), err=T.unsafe(nil), *rest); end
+class Fiddle::CStructEntity
+  include ::Fiddle::PackInfo
+  include ::Fiddle::ValueUtil
+  def [](*args); end
 
-  def self.def_e2message(k, c, m); end
+  def []=(*args); end
 
-  def self.def_exception(k, n, m, s=T.unsafe(nil)); end
+  def assign_names(members); end
 
-  def self.e2mm_message(klass, exp); end
+  def initialize(addr, types, func=T.unsafe(nil)); end
 
-  def self.extend_object(cl); end
+  def set_ctypes(types); end
 
-  def self.message(klass, exp); end
+  def to_s(); end
 end
 
-class ExitCalledError
+class Fiddle::CStructEntity
+  def self.alignment(types); end
+
+  def self.malloc(types, func=T.unsafe(nil), size=T.unsafe(nil), &block); end
+
+  def self.size(types); end
 end
 
-class ExitCalledError
+class Fiddle::CUnion
 end
 
-class Fiber
-  def transfer(*arg); end
+class Fiddle::CUnion
+  def self.entity_class(); end
+
+  def self.offsetof(name, members, types); end
 end
 
-class Fiber
-  def self.current(); end
+class Fiddle::CUnionEntity
+end
+
+class Fiddle::CUnionEntity
+end
+
+class Fiddle::ClearedReferenceError
+end
+
+class Fiddle::ClearedReferenceError
+end
+
+class Fiddle::CompositeHandler
+  def [](symbol); end
+
+  def handlers(); end
+
+  def initialize(handlers); end
+
+  def sym(symbol); end
+end
+
+class Fiddle::CompositeHandler
+end
+
+class Fiddle::Error
+end
+
+class Fiddle::Error
+end
+
+class Fiddle::Function
+  def need_gvl?(); end
+
+  def to_proc(); end
+end
+
+class Fiddle::Handle
+  def file_name(); end
+
+  def to_ptr(); end
+end
+
+module Fiddle::Importer
+  include ::Fiddle
+  include ::Fiddle::CParser
+end
+
+module Fiddle::Importer
+  extend ::Fiddle::Importer
+  extend ::Fiddle
+  extend ::Fiddle::CParser
+end
+
+class Fiddle::MemoryView
+  def [](*arg); end
+
+  def byte_size(); end
+
+  def format(); end
+
+  def initialize(arg); end
+
+  def item_size(); end
+
+  def ndim(); end
+
+  def obj(); end
+
+  def readonly?(); end
+
+  def release(); end
+
+  def shape(); end
+
+  def strides(); end
+
+  def sub_offsets(); end
+end
+
+class Fiddle::MemoryView
+  def self.export(arg); end
+end
+
+module Fiddle::PackInfo
+  ALIGN_MAP = ::T.let(nil, ::T.untyped)
+  PACK_MAP = ::T.let(nil, ::T.untyped)
+  SIZE_MAP = ::T.let(nil, ::T.untyped)
+end
+
+module Fiddle::PackInfo
+  def self.align(addr, align); end
+end
+
+class Fiddle::Packer
+  include ::Fiddle::PackInfo
+  def initialize(types); end
+
+  def pack(ary); end
+
+  def size(); end
+
+  def unpack(ary); end
+end
+
+class Fiddle::Packer
+  def self.[](*types); end
+end
+
+class Fiddle::Pinned
+  def clear(); end
+
+  def cleared?(); end
+
+  def initialize(arg); end
+
+  def ref(); end
+end
+
+class Fiddle::Pinned
+end
+
+class Fiddle::Pointer
+  def call_free(); end
+
+  def freed?(); end
+end
+
+class Fiddle::StructArray
+  include ::Fiddle::ValueUtil
+  def []=(index, value); end
+
+  def initialize(ptr, type, initial_values); end
+
+  def to_ptr(); end
+end
+
+class Fiddle::StructArray
+end
+
+module Fiddle::ValueUtil
+  def signed_value(val, ty); end
+
+  def unsigned_value(val, ty); end
+
+  def wrap_arg(arg, ty, funcs=T.unsafe(nil), &block); end
+
+  def wrap_args(args, tys, funcs, &block); end
+end
+
+module Fiddle::ValueUtil
 end
 
 class File
+  def self.absolute_path?(arg); end
+
   def self.atomic_write(file_name, temp_dir=T.unsafe(nil)); end
 
   def self.exists?(arg); end
@@ -4004,6 +4350,8 @@ end
 class FormulaConflict
   def self.[](*arg); end
 
+  def self.keyword_init?(); end
+
   def self.members(); end
 end
 
@@ -4024,20 +4372,65 @@ module Forwardable
 end
 
 module GC
-  def garbage_collect(*arg); end
+  def garbage_collect(full_mark: T.unsafe(nil), immediate_mark: T.unsafe(nil), immediate_sweep: T.unsafe(nil)); end
 end
 
 module GC
+  def self.latest_compact_info(); end
+
+  def self.measure_total_time(); end
+
+  def self.measure_total_time=(flag); end
+
+  def self.total_time(); end
+
+  def self.using_rvargc?(); end
+
   def self.verify_transient_heap_internal_consistency(); end
 end
 
+module Gem
+  HAVE_OPENSSL = ::T.let(nil, ::T.untyped)
+  KERNEL_WARN_IGNORES_INTERNAL_ENTRIES = ::T.let(nil, ::T.untyped)
+  UNTAINT = ::T.let(nil, ::T.untyped)
+end
+
+class Gem::BasicSpecification
+  def plugins(); end
+end
+
+module Gem::BundlerVersionFinder
+  def self.prioritize!(specs); end
+end
+
+class Gem::ConfigFile
+  def ipv4_fallback_enabled(); end
+
+  def ipv4_fallback_enabled=(ipv4_fallback_enabled); end
+  DEFAULT_IPV4_FALLBACK_ENABLED = ::T.let(nil, ::T.untyped)
+end
+
 class Gem::Dependency
   include ::Bundler::ForcePlatform
   def force_ruby_platform(); end
+
+  def prioritizes_bundler?(); end
 end
 
-class Gem::Exception
-  extend ::Gem::Deprecate
+class Gem::DependencyList
+  include ::Gem::TSort
+end
+
+module Gem::Deprecate
+  def deprecate(name, repl, year, month); end
+end
+
+module Gem::Deprecate
+  def self.next_rubygems_major_version(); end
+
+  def self.rubygems_deprecate(name, replacement=T.unsafe(nil)); end
+
+  def self.rubygems_deprecate_command(); end
 end
 
 class Gem::Ext::BuildError
@@ -4046,19 +4439,58 @@ end
 class Gem::Ext::BuildError
 end
 
-class Gem::Ext::Builder
-  def self.redirector(); end
+class Gem::Ext::CargoBuilder
+  def build(_extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil), cargo_dir=T.unsafe(nil)); end
+
+  def build_crate(dest_path, results, args, cargo_dir); end
+
+  def build_env(); end
+
+  def cargo_command(cargo_dir, dest_path, args=T.unsafe(nil)); end
+
+  def initialize(spec); end
+
+  def profile(); end
+
+  def profile=(profile); end
+
+  def runner(); end
+
+  def runner=(runner); end
+
+  def spec(); end
+
+  def spec=(spec); end
 end
 
-class Gem::Ext::ExtConfBuilder
+class Gem::Ext::CargoBuilder::DylibNotFoundError
+  def initialize(dir); end
 end
 
-Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_
+class Gem::Ext::CargoBuilder::DylibNotFoundError
+end
+
+class Gem::Ext::CargoBuilder
+end
+
+class Gem::Ext::ExtConfBuilder
+end
 
 class Gem::Ext::ExtConfBuilder
-  def self.build(extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil)); end
+  def self.build(extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil), extension_dir=T.unsafe(nil)); end
+
+  def self.get_relative_path(path, base); end
+end
 
-  def self.get_relative_path(path); end
+class Gem::Installer
+  include ::Gem::InstallerUninstallerUtils
+  def ensure_writable_dir(dir); end
+
+  def explicit_version_requirement(name); end
+
+  def gemdeps_load(name); end
+
+  def generate_plugins(); end
 end
 
 Gem::Installer::ExtensionBuildError = Gem::Ext::BuildError
@@ -4090,17 +4522,36 @@ end
 class Gem::Installer::FakePackage
 end
 
-class Gem::PathSupport
-  def home(); end
+class Gem::Installer
+  def self.inherited(klass); end
+end
 
-  def initialize(env); end
+module Gem::InstallerUninstallerUtils
+  def regenerate_plugins_for(spec, plugins_dir); end
 
-  def path(); end
+  def remove_plugins_for(spec, plugins_dir); end
+end
+
+module Gem::InstallerUninstallerUtils
+end
+
+class Gem::Licenses
+  LICENSE_REF = ::T.let(nil, ::T.untyped)
+end
+
+class Gem::PathSupport
+  def home(); end
+
+  def initialize(env); end
+
+  def path(); end
 
   def spec_cache_dir(); end
 end
 
 class Gem::Platform
+  def normalized_linux_version(); end
+
   def normalized_linux_version_ext(); end
   WINDOWS = ::T.let(nil, ::T.untyped)
   X64_LINUX = ::T.let(nil, ::T.untyped)
@@ -4111,6 +4562,8 @@ class Gem::Platform
   def self.match_gem?(platform, gem_name); end
 
   def self.match_spec?(spec); end
+
+  def self.sort_priority(platform); end
 end
 
 class Gem::Request
@@ -4119,19 +4572,31 @@ class Gem::Request
   extend ::Gem::Text
 end
 
+class Gem::RequestSet
+  include ::Gem::TSort
+end
+
+class Gem::RequestSet::Lockfile::Tokenizer::Token
+  def self.keyword_init?(); end
+end
+
 class Gem::Requirement
-  include ::Gem::Requirement::CorrectHashForLambdaOperator
+  def _sorted_requirements(); end
 end
 
-module Gem::Requirement::CorrectHashForLambdaOperator
-  def hash(); end
+class Gem::Resolver::APISet::GemParser
+  def parse(line); end
+end
+
+class Gem::Resolver::APISet::GemParser
 end
 
-module Gem::Requirement::CorrectHashForLambdaOperator
+class Gem::Resolver::APISpecification
+  def self.new(set, api_data); end
 end
 
 class Gem::Resolver::ActivationRequest
-  def others_possible?(); end
+  def eql?(other); end
 end
 
 class Gem::Resolver::CurrentSet
@@ -4140,7 +4605,15 @@ end
 class Gem::Resolver::CurrentSet
 end
 
-Gem::Resolver::DependencyConflict = Gem::Resolver::Conflict
+class Gem::Resolver::IndexSpecification
+  def ==(other); end
+end
+
+class Gem::Resolver::InstallerSet
+  def force(); end
+
+  def force=(force); end
+end
 
 class Gem::Resolver::LocalSpecification
 end
@@ -4148,6 +4621,22 @@ end
 class Gem::Resolver::LocalSpecification
 end
 
+module Gem::Resolver::Molinillo::Delegates::ResolutionState
+  def unused_unwind_options(); end
+end
+
+module Gem::Resolver::Molinillo::Delegates::SpecificationProvider
+  def dependencies_equal?(dependencies, other_dependencies); end
+end
+
+class Gem::Resolver::Molinillo::DependencyGraph
+  include ::Gem::TSort
+end
+
+class Gem::Resolver::Molinillo::DependencyGraph::Edge
+  def self.keyword_init?(); end
+end
+
 class Gem::Resolver::Molinillo::DependencyGraph::Log
   def add_edge_no_circular(graph, origin, destination, requirement); end
 
@@ -4174,6 +4663,118 @@ class Gem::Resolver::Molinillo::DependencyGraph::Log
   extend ::Enumerable
 end
 
+class Gem::Resolver::Molinillo::DependencyGraph::Vertex
+  def _path_to?(other, visited=T.unsafe(nil)); end
+
+  def _recursive_predecessors(vertices=T.unsafe(nil)); end
+
+  def _recursive_successors(vertices=T.unsafe(nil)); end
+end
+
+class Gem::Resolver::Molinillo::ResolutionState
+  def unused_unwind_options(); end
+
+  def unused_unwind_options=(_); end
+end
+
+class Gem::Resolver::Molinillo::ResolutionState
+  def self.keyword_init?(); end
+end
+
+class Gem::Resolver::Molinillo::Resolver::Resolution::Conflict
+  def possibility_set(); end
+
+  def possibility_set=(_); end
+
+  def underlying_error(); end
+
+  def underlying_error=(_); end
+end
+
+class Gem::Resolver::Molinillo::Resolver::Resolution::Conflict
+  def self.keyword_init?(); end
+end
+
+class Gem::Resolver::Molinillo::Resolver::Resolution::PossibilitySet
+  def dependencies(); end
+
+  def dependencies=(_); end
+
+  def latest_version(); end
+
+  def possibilities(); end
+
+  def possibilities=(_); end
+end
+
+class Gem::Resolver::Molinillo::Resolver::Resolution::PossibilitySet
+  def self.[](*arg); end
+
+  def self.keyword_init?(); end
+
+  def self.members(); end
+end
+
+class Gem::Resolver::Molinillo::Resolver::Resolution::UnwindDetails
+  include ::Comparable
+  def all_requirements(); end
+
+  def conflicting_requirements(); end
+
+  def conflicting_requirements=(_); end
+
+  def requirement_tree(); end
+
+  def requirement_tree=(_); end
+
+  def requirement_trees(); end
+
+  def requirement_trees=(_); end
+
+  def requirements_unwound_to_instead(); end
+
+  def requirements_unwound_to_instead=(_); end
+
+  def reversed_requirement_tree_index(); end
+
+  def state_index(); end
+
+  def state_index=(_); end
+
+  def state_requirement(); end
+
+  def state_requirement=(_); end
+
+  def sub_dependencies_to_avoid(); end
+
+  def unwinding_to_primary_requirement?(); end
+end
+
+class Gem::Resolver::Molinillo::Resolver::Resolution::UnwindDetails
+  def self.[](*arg); end
+
+  def self.keyword_init?(); end
+
+  def self.members(); end
+end
+
+module Gem::Resolver::Molinillo::SpecificationProvider
+  def dependencies_equal?(dependencies, other_dependencies); end
+end
+
+class Gem::Resolver::Molinillo::VersionConflict
+  include ::Gem::Resolver::Molinillo::Delegates::SpecificationProvider
+  def message_with_trees(opts=T.unsafe(nil)); end
+
+  def specification_provider(); end
+end
+
+class Gem::Resolver::Specification
+  def required_ruby_version(); end
+
+  def required_rubygems_version(); end
+end
+
 class Gem::RuntimeRequirementNotMetError
   def suggestion(); end
 
@@ -4205,7 +4806,7 @@ class Gem::SpecFetcher
 
   def specs(); end
 
-  def suggest_gems_from_name(gem_name, type=T.unsafe(nil)); end
+  def suggest_gems_from_name(gem_name, type=T.unsafe(nil), num_results=T.unsafe(nil)); end
 
   def tuples_for(source, type, gracefully_ignore=T.unsafe(nil)); end
 end
@@ -4221,13 +4822,21 @@ class Gem::Specification
   include ::Bundler::MatchPlatform
   include ::Bundler::GemHelpers
   include ::Gem::Specification::YamlBackfiller
+  def _deprecated_validate_dependencies(); end
+
+  def _deprecated_validate_metadata(); end
+
+  def _deprecated_validate_permissions(); end
+
   def deleted_gem?(); end
 
-  def rg_required_ruby_version=(req); end
+  def flatten_require_paths(); end
+
+  def removed_method_calls(); end
 
   def to_ruby(); end
   LATEST_RUBY_WITHOUT_PATCH_VERSIONS = ::T.let(nil, ::T.untyped)
-  ORIGINAL_LOCAL_PLATFORM = ::T.let(nil, ::T.untyped)
+  REMOVED_METHODS = ::T.let(nil, ::T.untyped)
 end
 
 module Gem::Specification::YamlBackfiller
@@ -4242,12 +4851,17 @@ class Gem::Specification
   extend ::Enumerable
   def self.add_spec(spec); end
 
-  def self.add_specs(*specs); end
+  def self.latest_spec_for(name); end
 
   def self.remove_spec(spec); end
+
+  def self.stubs_for_pattern(pattern, match_platform=T.unsafe(nil)); end
 end
 
 class Gem::SpecificationPolicy
+  include ::Gem::UserInteraction
+  include ::Gem::DefaultUserInteraction
+  include ::Gem::Text
   def initialize(specification); end
 
   def packaging(); end
@@ -4258,9 +4872,15 @@ class Gem::SpecificationPolicy
 
   def validate_dependencies(); end
 
+  def validate_duplicate_dependencies(); end
+
   def validate_metadata(); end
 
+  def validate_optional(strict); end
+
   def validate_permissions(); end
+
+  def validate_required!(); end
   HOMEPAGE_URI_PATTERN = ::T.let(nil, ::T.untyped)
   LAZY = ::T.let(nil, ::T.untyped)
   LAZY_PATTERN = ::T.let(nil, ::T.untyped)
@@ -4273,10 +4893,6 @@ end
 class Gem::SpecificationPolicy
 end
 
-class Gem::StreamUI
-  def _deprecated_debug(statement); end
-end
-
 class Gem::StubSpecification
   def build_extensions(); end
 
@@ -4311,6 +4927,34 @@ class Gem::StubSpecification
   def self.gemspec_stub(filename, base_dir, gems_dir); end
 end
 
+module Gem::TSort
+  def each_strongly_connected_component(&block); end
+
+  def each_strongly_connected_component_from(node, id_map=T.unsafe(nil), stack=T.unsafe(nil), &block); end
+
+  def strongly_connected_components(); end
+
+  def tsort(); end
+
+  def tsort_each(&block); end
+
+  def tsort_each_child(node); end
+
+  def tsort_each_node(); end
+end
+
+module Gem::TSort
+  def self.each_strongly_connected_component(each_node, each_child); end
+
+  def self.each_strongly_connected_component_from(node, each_child, id_map=T.unsafe(nil), stack=T.unsafe(nil)); end
+
+  def self.strongly_connected_components(each_node, each_child); end
+
+  def self.tsort(each_node, each_child); end
+
+  def self.tsort_each(each_node, each_child); end
+end
+
 class Gem::UninstallError
   def spec(); end
 
@@ -4320,12 +4964,57 @@ end
 class Gem::UninstallError
 end
 
+class Gem::UnknownCommandError
+  def initialize(unknown_command); end
+
+  def unknown_command(); end
+end
+
+class Gem::UnknownCommandError
+  def self.attach_correctable(); end
+end
+
+class Gem::UnknownCommandSpellChecker
+  def corrections(); end
+
+  def error(); end
+
+  def initialize(error); end
+end
+
+class Gem::UnknownCommandSpellChecker
+end
+
+module Gem::Util
+  def self._deprecated_silent_system(*command); end
+end
+
 Gem::Version::Requirement = Gem::Requirement
 
 module Gem
-  def self.default_gems_use_full_paths?(); end
+  def self.activated_gem_paths(); end
+
+  def self.cache_home(); end
+
+  def self.config_home(); end
+
+  def self.data_home(); end
+
+  def self.disable_system_update_message(); end
+
+  def self.disable_system_update_message=(disable_system_update_message); end
+
+  def self.find_config_file(); end
+
+  def self.open_file(path, flags, &block); end
+
+  def self.plugin_suffix_pattern(); end
 
-  def self.remove_unresolved_default_spec(spec); end
+  def self.plugin_suffix_regexp(); end
+
+  def self.plugindir(install_dir=T.unsafe(nil)); end
+
+  def self.solaris_platform?(); end
 end
 
 module GitHub::API
@@ -4356,6 +5045,16 @@ module Hardware
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class Hash
+  def deconstruct_keys(arg); end
+end
+
+class Hash
+  def self.ruby2_keywords_hash(arg); end
+
+  def self.ruby2_keywords_hash?(arg); end
+end
+
 module Homebrew::API::Analytics
   extend ::T::Private::Methods::SingletonMethodHooks
 end
@@ -4376,6 +5075,8 @@ end
 class Homebrew::Completions::Variables
   def self.[](*arg); end
 
+  def self.keyword_init?(); end
+
   def self.members(); end
 end
 
@@ -4405,16 +5106,18 @@ module Homebrew::Livecheck::SkipConditions
 end
 
 class Homebrew::Livecheck::Strategy::Sparkle::Item
-  def nice_version(*args, &block); end
+  def nice_version(*args, **arg, &block); end
 
-  def short_version(*args, &block); end
+  def short_version(*args, **arg, &block); end
 
-  def version(*args, &block); end
+  def version(*args, **arg, &block); end
 end
 
 class Homebrew::Livecheck::Strategy::Sparkle::Item
   def self.[](*arg); end
 
+  def self.keyword_init?(); end
+
   def self.members(); end
 end
 
@@ -4476,23 +5179,45 @@ end
 class IO
   def beep(); end
 
+  def check_winsize_changed(); end
+
+  def clear_screen(); end
+
+  def console_mode(); end
+
+  def console_mode=(console_mode); end
+
   def cooked(); end
 
   def cooked!(); end
 
   def cursor(); end
 
-  def cursor=(); end
+  def cursor=(cursor); end
+
+  def cursor_down(arg); end
+
+  def cursor_left(arg); end
+
+  def cursor_right(arg); end
+
+  def cursor_up(arg); end
 
   def echo=(echo); end
 
   def echo?(); end
 
+  def erase_line(arg); end
+
+  def erase_screen(arg); end
+
   def getch(*arg); end
 
   def getpass(*arg); end
 
-  def goto(); end
+  def goto(arg, arg1); end
+
+  def goto_column(arg); end
 
   def iflush(); end
 
@@ -4520,8 +5245,14 @@ class IO
 
   def ready?(); end
 
+  def scroll_backward(arg); end
+
+  def scroll_forward(arg); end
+
   def wait(*arg); end
 
+  def wait_priority(*arg); end
+
   def wait_readable(*arg); end
 
   def wait_writable(*arg); end
@@ -4529,182 +5260,404 @@ class IO
   def winsize(); end
 
   def winsize=(winsize); end
+  PRIORITY = ::T.let(nil, ::T.untyped)
+  READABLE = ::T.let(nil, ::T.untyped)
+  WRITABLE = ::T.let(nil, ::T.untyped)
 end
 
-class IO
-  def self.console(*arg); end
-end
+class IO::Buffer
+  include ::Comparable
+  def clear(*arg); end
 
-class IPAddr
-  def ==(other); end
+  def copy(*arg); end
 
-  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
-end
+  def empty?(); end
 
-module IRB
-  IRBRC_EXT = ::T.let(nil, ::T.untyped)
-  MagicFile = ::T.let(nil, ::T.untyped)
-  STDIN_FILE_NAME = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-end
+  def external?(); end
 
-class IRB::Context
-  def __exit__(*arg); end
+  def free(); end
 
-  def __inspect__(); end
+  def get_string(*arg); end
 
-  def __to_s__(); end
+  def get_value(arg, arg1); end
 
-  def evaluate(line, line_no, exception: T.unsafe(nil)); end
+  def hexdump(); end
 
-  def initialize(irb, workspace=T.unsafe(nil), input_method=T.unsafe(nil), output_method=T.unsafe(nil)); end
+  def initialize(*arg); end
 
-  def inspect_last_value(); end
-  IDNAME_IVARS = ::T.let(nil, ::T.untyped)
-  NOPRINTING_IVARS = ::T.let(nil, ::T.untyped)
-  NO_INSPECTING_IVARS = ::T.let(nil, ::T.untyped)
-end
+  def internal?(); end
 
-class IRB::DefaultEncodings
-  def external(); end
+  def locked(); end
 
-  def external=(_); end
+  def locked?(); end
 
-  def internal=(_); end
-end
+  def mapped?(); end
 
-class IRB::DefaultEncodings
-  def self.[](*arg); end
+  def null?(); end
 
-  def self.members(); end
-end
+  def pread(arg, arg1, arg2); end
 
-module IRB::ExtendCommandBundle
-  def irb(*opts, &b); end
+  def pwrite(arg, arg1, arg2); end
 
-  def irb_change_workspace(*opts, &b); end
+  def read(arg, arg1); end
 
-  def irb_current_working_workspace(*opts, &b); end
+  def readonly?(); end
 
-  def irb_fg(*opts, &b); end
+  def resize(arg); end
 
-  def irb_help(*opts, &b); end
+  def set_string(*arg); end
 
-  def irb_jobs(*opts, &b); end
+  def set_value(arg, arg1, arg2); end
 
-  def irb_kill(*opts, &b); end
+  def size(); end
 
-  def irb_pop_workspace(*opts, &b); end
+  def slice(arg, arg1); end
 
-  def irb_push_workspace(*opts, &b); end
+  def transfer(); end
 
-  def irb_source(*opts, &b); end
+  def valid?(); end
 
-  def irb_workspaces(*opts, &b); end
+  def write(arg, arg1); end
+  BIG_ENDIAN = ::T.let(nil, ::T.untyped)
+  DEFAULT_SIZE = ::T.let(nil, ::T.untyped)
+  EXTERNAL = ::T.let(nil, ::T.untyped)
+  HOST_ENDIAN = ::T.let(nil, ::T.untyped)
+  INTERNAL = ::T.let(nil, ::T.untyped)
+  LITTLE_ENDIAN = ::T.let(nil, ::T.untyped)
+  LOCKED = ::T.let(nil, ::T.untyped)
+  MAPPED = ::T.let(nil, ::T.untyped)
+  NETWORK_ENDIAN = ::T.let(nil, ::T.untyped)
+  PAGE_SIZE = ::T.let(nil, ::T.untyped)
+  PRIVATE = ::T.let(nil, ::T.untyped)
+  READONLY = ::T.let(nil, ::T.untyped)
 end
 
-IRB::ExtendCommandBundle::EXCB = IRB::ExtendCommandBundle
-
-module IRB::ExtendCommandBundle
-  def self.irb_original_method_name(method_name); end
+class IO::Buffer::AccessError
 end
 
-class IRB::FileInputMethod
-  def initialize(file); end
+class IO::Buffer::AccessError
 end
 
-class IRB::InputMethod
-  def initialize(file=T.unsafe(nil)); end
+class IO::Buffer::AllocationError
 end
 
-class IRB::Inspector
-  def initialize(inspect_proc, init_proc=T.unsafe(nil)); end
+class IO::Buffer::AllocationError
 end
 
-class IRB::Irb
-  def handle_exception(exc); end
-
-  def initialize(workspace=T.unsafe(nil), input_method=T.unsafe(nil), output_method=T.unsafe(nil)); end
+class IO::Buffer::InvalidatedError
+end
 
-  def output_value(); end
+class IO::Buffer::InvalidatedError
+end
 
-  def prompt(prompt, ltype, indent, line_no); end
+class IO::Buffer::LockedError
 end
 
-class IRB::Locale
-  def String(mes); end
+class IO::Buffer::LockedError
+end
 
-  def encoding(); end
+class IO::Buffer
+  def self.for(arg); end
 
-  def find(file, paths=T.unsafe(nil)); end
+  def self.map(*arg); end
+end
 
-  def format(*opts); end
+class IO::ConsoleMode
+  def echo=(echo); end
 
-  def gets(*rs); end
+  def raw(*arg); end
 
-  def initialize(locale=T.unsafe(nil)); end
+  def raw!(*arg); end
+end
 
-  def lang(); end
+class IO::ConsoleMode
+end
 
-  def load(file, priv=T.unsafe(nil)); end
+class IO
+  def self.console(*arg); end
 
-  def modifier(); end
+  def self.console_size(); end
 
-  def print(*opts); end
+  def self.default_console_size(); end
 
-  def printf(*opts); end
+  def self.new(*arg); end
+end
 
-  def puts(*opts); end
+class IPAddr
+  def ==(other); end
 
-  def readline(*rs); end
+  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
 
-  def require(file, priv=T.unsafe(nil)); end
+  def netmask(); end
 
-  def territory(); end
-  LOCALE_DIR = ::T.let(nil, ::T.untyped)
-  LOCALE_NAME_RE = ::T.let(nil, ::T.untyped)
+  def zone_id(); end
+
+  def zone_id=(zid); end
+  VERSION = ::T.let(nil, ::T.untyped)
 end
 
-class IRB::Locale
+module IRB
+  IRBRC_EXT = ::T.let(nil, ::T.untyped)
+  MagicFile = ::T.let(nil, ::T.untyped)
+  STDIN_FILE_NAME = ::T.let(nil, ::T.untyped)
+  TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
 end
 
-class IRB::Notifier::AbstractNotifier
-  def initialize(prefix, base_notifier); end
+module IRB::Color
+  BLUE = ::T.let(nil, ::T.untyped)
+  BOLD = ::T.let(nil, ::T.untyped)
+  CLEAR = ::T.let(nil, ::T.untyped)
+  CYAN = ::T.let(nil, ::T.untyped)
+  GREEN = ::T.let(nil, ::T.untyped)
+  MAGENTA = ::T.let(nil, ::T.untyped)
+  RED = ::T.let(nil, ::T.untyped)
+  REVERSE = ::T.let(nil, ::T.untyped)
+  UNDERLINE = ::T.let(nil, ::T.untyped)
+  YELLOW = ::T.let(nil, ::T.untyped)
 end
 
-class IRB::Notifier::LeveledNotifier
-  def initialize(base, level, prefix); end
+module IRB::Color
+  def self.clear(colorable: T.unsafe(nil)); end
+
+  def self.colorable?(); end
+
+  def self.colorize(text, seq, colorable: T.unsafe(nil)); end
+
+  def self.colorize_code(code, complete: T.unsafe(nil), ignore_error: T.unsafe(nil), colorable: T.unsafe(nil)); end
+
+  def self.inspect_colorable?(obj, seen: T.unsafe(nil)); end
 end
 
-class IRB::Notifier::NoMsgNotifier
-  def initialize(); end
+class IRB::Context
+  def __exit__(*arg); end
+
+  def __inspect__(); end
+
+  def __to_s__(); end
+
+  def echo_on_assignment(); end
+
+  def echo_on_assignment=(echo_on_assignment); end
+
+  def echo_on_assignment?(); end
+
+  def evaluate(line, line_no, exception: T.unsafe(nil)); end
+
+  def extra_doc_dirs(); end
+
+  def extra_doc_dirs=(extra_doc_dirs); end
+
+  def initialize(irb, workspace=T.unsafe(nil), input_method=T.unsafe(nil)); end
+
+  def inspect_last_value(); end
+
+  def newline_before_multiline_output(); end
+
+  def newline_before_multiline_output=(newline_before_multiline_output); end
+
+  def newline_before_multiline_output?(); end
+
+  def use_autocomplete(); end
+
+  def use_autocomplete?(); end
+
+  def use_colorize(); end
+
+  def use_colorize?(); end
+
+  def use_multiline(); end
+
+  def use_multiline?(); end
+
+  def use_reidline(); end
+
+  def use_reidline?(); end
+
+  def use_singleline(); end
+
+  def use_singleline?(); end
+  IDNAME_IVARS = ::T.let(nil, ::T.untyped)
+  NOPRINTING_IVARS = ::T.let(nil, ::T.untyped)
+  NO_INSPECTING_IVARS = ::T.let(nil, ::T.untyped)
 end
 
-class IRB::ReadlineInputMethod
-  def initialize(); end
+class IRB::DefaultEncodings
+  def external(); end
+
+  def external=(_); end
+
+  def internal=(_); end
+end
+
+class IRB::DefaultEncodings
+  def self.[](*arg); end
+
+  def self.keyword_init?(); end
+
+  def self.members(); end
+end
+
+module IRB::ExtendCommandBundle
+  def irb(*opts, **kwargs, &b); end
+
+  def irb_change_workspace(*opts, **kwargs, &b); end
+
+  def irb_current_working_workspace(*opts, **kwargs, &b); end
+
+  def irb_fg(*opts, **kwargs, &b); end
+
+  def irb_help(*opts, **kwargs, &b); end
+
+  def irb_info(*opts, **kwargs, &b); end
+
+  def irb_jobs(*opts, **kwargs, &b); end
+
+  def irb_kill(*opts, **kwargs, &b); end
+
+  def irb_ls(*opts, **kwargs, &b); end
+
+  def irb_measure(*opts, **kwargs, &b); end
+
+  def irb_pop_workspace(*opts, **kwargs, &b); end
+
+  def irb_push_workspace(*opts, **kwargs, &b); end
+
+  def irb_show_source(*opts, **kwargs, &b); end
+
+  def irb_source(*opts, **kwargs, &b); end
+
+  def irb_whereami(*opts, **kwargs, &b); end
+
+  def irb_workspaces(*opts, **kwargs, &b); end
+end
+
+IRB::ExtendCommandBundle::EXCB = IRB::ExtendCommandBundle
+
+module IRB::ExtendCommandBundle
+  def self.irb_original_method_name(method_name); end
+end
+
+class IRB::FileInputMethod
+  def close(); end
+
+  def initialize(file); end
+end
+
+class IRB::FileInputMethod
+  def self.open(file, &block); end
+end
+
+module IRB::InputCompletor
+  BASIC_WORD_BREAK_CHARACTERS = ::T.let(nil, ::T.untyped)
+  CompletionProc = ::T.let(nil, ::T.untyped)
+  CompletionRequireProc = ::T.let(nil, ::T.untyped)
+  Operators = ::T.let(nil, ::T.untyped)
+  PerfectMatchedProc = ::T.let(nil, ::T.untyped)
+  ReservedWords = ::T.let(nil, ::T.untyped)
+end
+
+module IRB::InputCompletor
+  def self.absolute_path?(p); end
+
+  def self.ignored_modules(); end
+
+  def self.retrieve_completion_data(input, bind: T.unsafe(nil), doc_namespace: T.unsafe(nil)); end
+
+  def self.retrieve_files_to_require_from_load_path(); end
+
+  def self.retrieve_files_to_require_relative_from_current_dir(); end
+
+  def self.retrieve_gem_and_system_load_path(); end
+
+  def self.select_message(receiver, message, candidates, sep=T.unsafe(nil)); end
+end
+
+class IRB::InputMethod
+  def initialize(file=T.unsafe(nil)); end
+
+  def winsize(); end
+end
+
+class IRB::Inspector
+  def initialize(inspect_proc, init_proc=T.unsafe(nil)); end
+end
+
+class IRB::Irb
+  def assignment_expression?(line); end
+
+  def convert_invalid_byte_sequence(str, enc); end
+
+  def encode_with_invalid_byte_sequence(str, enc); end
+
+  def handle_exception(exc); end
+
+  def initialize(workspace=T.unsafe(nil), input_method=T.unsafe(nil)); end
+
+  def output_value(omit=T.unsafe(nil)); end
+
+  def prompt(prompt, ltype, indent, line_no); end
+  ASSIGNMENT_NODE_TYPES = ::T.let(nil, ::T.untyped)
 end
 
-class IRB::SLex
-  def Fail(err=T.unsafe(nil), *rest); end
+class IRB::Locale
+  def String(mes); end
+
+  def encoding(); end
+
+  def find(file, paths=T.unsafe(nil)); end
+
+  def format(*opts); end
+
+  def gets(*rs); end
+
+  def initialize(locale=T.unsafe(nil)); end
+
+  def lang(); end
+
+  def load(file, priv=T.unsafe(nil)); end
+
+  def modifier(); end
+
+  def print(*opts); end
+
+  def printf(*opts); end
+
+  def puts(*opts); end
+
+  def readline(*rs); end
+
+  def require(file, priv=T.unsafe(nil)); end
 
-  def Raise(err=T.unsafe(nil), *rest); end
+  def territory(); end
+  LOCALE_DIR = ::T.let(nil, ::T.untyped)
+  LOCALE_NAME_RE = ::T.let(nil, ::T.untyped)
 end
 
-class IRB::SLex::ErrNodeAlreadyExists
+class IRB::Locale
 end
 
-class IRB::SLex::ErrNodeAlreadyExists
+class IRB::OutputMethod::NotImplementedError
+  def initialize(val); end
 end
 
-class IRB::SLex::ErrNodeNothing
+class IRB::ReadlineInputMethod
+  def initialize(); end
 end
 
-class IRB::SLex::ErrNodeNothing
+class IRB::ReadlineInputMethod
+  def self.initialize_readline(); end
 end
 
-class IRB::SLex
-  extend ::Exception2MessageMapper
-  def self.included(mod); end
+class IRB::ReidlineInputMethod
+  def auto_indent(&block); end
+
+  def check_termination(&block); end
+
+  def dynamic_prompt(&block); end
+
+  def initialize(); end
+  SHOW_DOC_DIALOG = ::T.let(nil, ::T.untyped)
 end
 
 class IRB::StdioInputMethod
@@ -4738,13 +5691,21 @@ module IRB
 
   def self.run_config(); end
 
+  def self.set_measure_callback(type=T.unsafe(nil), arg=T.unsafe(nil), &block); end
+
   def self.setup(ap_path, argv: T.unsafe(nil)); end
+
+  def self.unset_measure_callback(type=T.unsafe(nil)); end
 end
 
 class Integer
   def to_bn(); end
 end
 
+class Integer
+  def self.try_convert(arg); end
+end
+
 class JSON::Ext::Generator::State
   def escape_slash(); end
 
@@ -4761,18 +5722,26 @@ class JSON::Ext::Parser
   def initialize(*arg); end
 end
 
+class JSONSchemer::Result
+  def self.keyword_init?(); end
+end
+
+class JSONSchemer::Schema::Context
+  def self.keyword_init?(); end
+end
+
 module Kernel
   include ::ActiveSupport::ForkTracker::CoreExtPrivate
   include ::ActiveSupport::ForkTracker::CoreExt
-  def agree(*args, &block); end
+  def agree(*args, **arg, &block); end
 
-  def ask(*args, &block); end
+  def ask(*args, **arg, &block); end
 
-  def choose(*args, &block); end
+  def choose(*args, **arg, &block); end
 
   def pretty_inspect(); end
 
-  def say(*args, &block); end
+  def say(*args, **arg, &block); end
 end
 
 module Kernel
@@ -4819,15 +5788,33 @@ module Language::Python::Virtualenv
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class LazyObject
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
 class LinuxRunnerSpec
   def self.inherited(s); end
 end
 
+class LoadError
+  include ::DidYouMean::Correctable
+end
+
 class Logger
+  def debug!(); end
+
+  def error!(); end
+
+  def fatal!(); end
+
+  def info!(); end
+
+  def warn!(); end
   SEV_LABEL = ::T.let(nil, ::T.untyped)
 end
 
 class Logger::Formatter
+  DatetimeFormat = ::T.let(nil, ::T.untyped)
   Format = ::T.let(nil, ::T.untyped)
 end
 
@@ -4847,6 +5834,12 @@ module Marshal
   extend ::ActiveSupport::MarshalWithAutoloading
 end
 
+class MatchData
+  def match(arg); end
+
+  def match_length(arg); end
+end
+
 class Mechanize::HTTP
 end
 
@@ -4881,6 +5874,8 @@ end
 class Mechanize::HTTP::ContentDisposition
   def self.[](*arg); end
 
+  def self.keyword_init?(); end
+
   def self.members(); end
 end
 
@@ -4909,6 +5904,10 @@ end
 class Mechanize::HTTP
 end
 
+class MessagePack::ExtensionValue
+  def self.keyword_init?(); end
+end
+
 class MessagePack::Packer
   def register_type_internal(arg, arg1, arg2); end
 
@@ -4925,6 +5924,14 @@ class MessagePack::Unpacker
   def freeze?(); end
 end
 
+class Method
+  def private?(); end
+
+  def protected?(); end
+
+  def public?(); end
+end
+
 module Minitest::Assertions
   def assert_mock(mock); end
 end
@@ -4942,77 +5949,79 @@ end
 class Minitest::Expectation
   def self.[](*arg); end
 
+  def self.keyword_init?(); end
+
   def self.members(); end
 end
 
 module Minitest::Expectations
-  def must_be(*args); end
+  def must_be(*args, **arg); end
 
-  def must_be_close_to(*args); end
+  def must_be_close_to(*args, **arg); end
 
-  def must_be_empty(*args); end
+  def must_be_empty(*args, **arg); end
 
-  def must_be_instance_of(*args); end
+  def must_be_instance_of(*args, **arg); end
 
-  def must_be_kind_of(*args); end
+  def must_be_kind_of(*args, **arg); end
 
-  def must_be_nil(*args); end
+  def must_be_nil(*args, **arg); end
 
-  def must_be_same_as(*args); end
+  def must_be_same_as(*args, **arg); end
 
-  def must_be_silent(*args); end
+  def must_be_silent(*args, **arg); end
 
-  def must_be_within_delta(*args); end
+  def must_be_within_delta(*args, **arg); end
 
-  def must_be_within_epsilon(*args); end
+  def must_be_within_epsilon(*args, **arg); end
 
-  def must_equal(*args); end
+  def must_equal(*args, **arg); end
 
-  def must_include(*args); end
+  def must_include(*args, **arg); end
 
-  def must_match(*args); end
+  def must_match(*args, **arg); end
 
-  def must_output(*args); end
+  def must_output(*args, **arg); end
 
-  def must_pattern_match(*args); end
+  def must_pattern_match(*args, **arg); end
 
-  def must_raise(*args); end
+  def must_raise(*args, **arg); end
 
-  def must_respond_to(*args); end
+  def must_respond_to(*args, **arg); end
 
-  def must_throw(*args); end
+  def must_throw(*args, **arg); end
 
-  def path_must_exist(*args); end
+  def path_must_exist(*args, **arg); end
 
-  def path_wont_exist(*args); end
+  def path_wont_exist(*args, **arg); end
 
-  def wont_be(*args); end
+  def wont_be(*args, **arg); end
 
-  def wont_be_close_to(*args); end
+  def wont_be_close_to(*args, **arg); end
 
-  def wont_be_empty(*args); end
+  def wont_be_empty(*args, **arg); end
 
-  def wont_be_instance_of(*args); end
+  def wont_be_instance_of(*args, **arg); end
 
-  def wont_be_kind_of(*args); end
+  def wont_be_kind_of(*args, **arg); end
 
-  def wont_be_nil(*args); end
+  def wont_be_nil(*args, **arg); end
 
-  def wont_be_same_as(*args); end
+  def wont_be_same_as(*args, **arg); end
 
-  def wont_be_within_delta(*args); end
+  def wont_be_within_delta(*args, **arg); end
 
-  def wont_be_within_epsilon(*args); end
+  def wont_be_within_epsilon(*args, **arg); end
 
-  def wont_equal(*args); end
+  def wont_equal(*args, **arg); end
 
-  def wont_include(*args); end
+  def wont_include(*args, **arg); end
 
-  def wont_match(*args); end
+  def wont_match(*args, **arg); end
 
-  def wont_pattern_match(*args); end
+  def wont_pattern_match(*args, **arg); end
 
-  def wont_respond_to(*args); end
+  def wont_respond_to(*args, **arg); end
 end
 
 module Minitest::Expectations
@@ -5154,13 +6163,33 @@ class Monitor
 
   def exit(); end
 
+  def mon_check_owner(); end
+
+  def mon_enter(); end
+
+  def mon_exit(); end
+
+  def mon_locked?(); end
+
+  def mon_owned?(); end
+
+  def mon_synchronize(); end
+
+  def mon_try_enter(); end
+
+  def new_cond(); end
+
+  def synchronize(); end
+
   def try_enter(); end
+
+  def try_mon_enter(); end
+
+  def wait_for_cond(arg, arg1); end
 end
 
 module MonitorMixin
-  def initialize(*args); end
-  EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped)
-  EXCEPTION_NEVER = ::T.let(nil, ::T.untyped)
+  def initialize(*arg, **arg1, &arg2); end
 end
 
 class MonitorMixin::ConditionVariable
@@ -5171,6 +6200,10 @@ module Mutex_m
   VERSION = ::T.let(nil, ::T.untyped)
 end
 
+class NameError
+  include ::ErrorHighlight::CoreExt
+end
+
 class Net::BufferedIO
   def write_timeout(); end
 
@@ -5178,6 +6211,18 @@ class Net::BufferedIO
 end
 
 class Net::HTTP
+  def extra_chain_cert(); end
+
+  def extra_chain_cert=(extra_chain_cert); end
+
+  def ignore_eof(); end
+
+  def ignore_eof=(ignore_eof); end
+
+  def ipaddr(); end
+
+  def ipaddr=(addr); end
+
   def max_retries(); end
 
   def max_retries=(retries); end
@@ -5190,10 +6235,18 @@ class Net::HTTP
 
   def min_version=(min_version); end
 
+  def response_body_encoding(); end
+
+  def response_body_encoding=(value); end
+
+  def verify_hostname(); end
+
+  def verify_hostname=(verify_hostname); end
+
   def write_timeout(); end
 
   def write_timeout=(sec); end
-  ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
 end
 
 class Net::HTTPAlreadyReported
@@ -5203,7 +6256,7 @@ end
 class Net::HTTPAlreadyReported
 end
 
-Net::HTTPClientError::EXCEPTION_TYPE = Net::HTTPServerException
+Net::HTTPClientError::EXCEPTION_TYPE = Net::HTTPClientException
 
 Net::HTTPClientErrorCode = Net::HTTPClientError
 
@@ -5270,14 +6323,28 @@ end
 class Net::HTTPRangeNotSatisfiable
 end
 
-Net::HTTPRedirection::EXCEPTION_TYPE = Net::HTTPRetriableError
-
 Net::HTTPRedirectionCode = Net::HTTPRedirection
 
 Net::HTTPRequestURITooLarge = Net::HTTPURITooLong
 
 Net::HTTPResponceReceiver = Net::HTTPResponse
 
+class Net::HTTPResponse
+  def body_encoding(); end
+
+  def body_encoding=(value); end
+
+  def ignore_eof(); end
+
+  def ignore_eof=(ignore_eof); end
+end
+
+class Net::HTTPResponse::Inflater
+  def bytes_inflated(); end
+end
+
+Net::HTTPResponseReceiver = Net::HTTPResponse
+
 Net::HTTPRetriableCode = Net::HTTPRedirection
 
 Net::HTTPServerError::EXCEPTION_TYPE = Net::HTTPFatalError
@@ -5286,8 +6353,6 @@ Net::HTTPServerErrorCode = Net::HTTPServerError
 
 Net::HTTPSession = Net::HTTP
 
-Net::HTTPSuccess::EXCEPTION_TYPE = Net::HTTPError
-
 Net::HTTPSuccessCode = Net::HTTPSuccess
 
 class Net::HTTPURITooLong
@@ -5312,6 +6377,10 @@ Net::NetPrivate::Socket = Net::InternetMessageIO
 
 Net::ProtocRetryError = Net::ProtoRetriableError
 
+class Net::Protocol
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
 class Net::ReadTimeout
   def initialize(io=T.unsafe(nil)); end
 
@@ -5328,18 +6397,34 @@ class NilClass
   def to_d(); end
 end
 
-module OS::Linux::Glibc
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
+class NoMatchingPatternError
 end
 
-module OS::Linux::Kernel
+class NoMatchingPatternError
+end
+
+class NoMatchingPatternKeyError
+  include ::DidYouMean::Correctable
+  def key(); end
+
+  def matchee(); end
+end
+
+class NoMatchingPatternKeyError
+end
+
+module OS::Linux::Glibc
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+module OS::Linux::Kernel
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
 class OS::Mac::BaseSDKLocator
-  def initialize(*args, &blk); end
+  def initialize(*args, **arg, &blk); end
 end
 
 class OS::Mac::BaseSDKLocator
@@ -5377,7 +6462,6 @@ class Object
   def stub(name, val_or_callable, *block_args, **block_kwargs, &block); end
 
   def to_yaml(options=T.unsafe(nil)); end
-  APPLE_GEM_HOME = ::T.let(nil, ::T.untyped)
   ARGF = ::T.let(nil, ::T.untyped)
   ARGV = ::T.let(nil, ::T.untyped)
   BUG_REPORTS_URL = ::T.let(nil, ::T.untyped)
@@ -5460,8 +6544,6 @@ class Object
   RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped)
   RUBY_ENGINE = ::T.let(nil, ::T.untyped)
   RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped)
-  RUBY_FRAMEWORK = ::T.let(nil, ::T.untyped)
-  RUBY_FRAMEWORK_VERSION = ::T.let(nil, ::T.untyped)
   RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped)
   RUBY_PATH = ::T.let(nil, ::T.untyped)
   RUBY_PLATFORM = ::T.let(nil, ::T.untyped)
@@ -5503,6 +6585,10 @@ module OnSystem
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+module Open3
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
 class OpenSSL::ASN1::ASN1Data
   def indefinite_length(); end
 
@@ -5516,7 +6602,60 @@ class OpenSSL::BN
 
   def /(arg); end
 
+  def abs(); end
+
+  def get_flags(arg); end
+
   def negative?(); end
+
+  def set_flags(arg); end
+  CONSTTIME = ::T.let(nil, ::T.untyped)
+end
+
+module OpenSSL::Buffering
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+  def getbyte(); end
+end
+
+class OpenSSL::Buffering::Buffer
+  def <<(string); end
+
+  def concat(string); end
+
+  def initialize(); end
+  BINARY = ::T.let(nil, ::T.untyped)
+end
+
+class OpenSSL::Buffering::Buffer
+end
+
+class OpenSSL::Cipher
+  def ccm_data_len=(ccm_data_len); end
+end
+
+class OpenSSL::HMAC
+  def ==(other); end
+
+  def base64digest(); end
+end
+
+class OpenSSL::HMAC
+  def self.base64digest(digest, key, data); end
+end
+
+module OpenSSL::Marshal
+  def _dump(_level); end
+end
+
+module OpenSSL::Marshal::ClassMethods
+  def _load(string); end
+end
+
+module OpenSSL::Marshal::ClassMethods
+end
+
+module OpenSSL::Marshal
+  def self.included(base); end
 end
 
 class OpenSSL::OCSP::Request
@@ -5525,20 +6664,105 @@ end
 
 OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo
 
+class OpenSSL::PKey::DH
+  include ::OpenSSL::Marshal
+end
+
+class OpenSSL::PKey::DH
+  extend ::OpenSSL::Marshal::ClassMethods
+  def self.new(*args, &blk); end
+end
+
+class OpenSSL::PKey::DSA
+  include ::OpenSSL::Marshal
+end
+
+class OpenSSL::PKey::DSA
+  extend ::OpenSSL::Marshal::ClassMethods
+  def self.new(*args, &blk); end
+end
+
+class OpenSSL::PKey::EC
+  include ::OpenSSL::Marshal
+  EXPLICIT_CURVE = ::T.let(nil, ::T.untyped)
+end
+
 class OpenSSL::PKey::EC::Point
+  def add(arg); end
+
   def to_octet_string(arg); end
 end
 
+class OpenSSL::PKey::EC
+  extend ::OpenSSL::Marshal::ClassMethods
+end
+
+class OpenSSL::PKey::PKey
+  def compare?(arg); end
+
+  def decrypt(*arg); end
+
+  def derive(*arg); end
+
+  def encrypt(*arg); end
+
+  def oid(); end
+
+  def private_to_der(*arg); end
+
+  def private_to_pem(*arg); end
+
+  def public_to_der(); end
+
+  def public_to_pem(); end
+
+  def sign_raw(*arg); end
+
+  def to_text(); end
+
+  def verify_raw(*arg); end
+
+  def verify_recover(*arg); end
+end
+
+class OpenSSL::PKey::RSA
+  include ::OpenSSL::Marshal
+end
+
+class OpenSSL::PKey::RSA
+  extend ::OpenSSL::Marshal::ClassMethods
+  def self.new(*args, &blk); end
+end
+
+module OpenSSL::PKey
+  def self.generate_key(*arg); end
+
+  def self.generate_parameters(*arg); end
+end
+
 module OpenSSL::SSL
+  OP_ALLOW_CLIENT_RENEGOTIATION = ::T.let(nil, ::T.untyped)
+  OP_ALLOW_NO_DHE_KEX = ::T.let(nil, ::T.untyped)
   OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped)
+  OP_CLEANSE_PLAINTEXT = ::T.let(nil, ::T.untyped)
   OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped)
+  OP_DISABLE_TLSEXT_CA_NAMES = ::T.let(nil, ::T.untyped)
+  OP_ENABLE_KTLS = ::T.let(nil, ::T.untyped)
+  OP_ENABLE_MIDDLEBOX_COMPAT = ::T.let(nil, ::T.untyped)
+  OP_IGNORE_UNEXPECTED_EOF = ::T.let(nil, ::T.untyped)
   OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped)
+  OP_NO_ANTI_REPLAY = ::T.let(nil, ::T.untyped)
+  OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped)
+  OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped)
+  OP_NO_TLSv1_3 = ::T.let(nil, ::T.untyped)
+  OP_PRIORITIZE_CHACHA = ::T.let(nil, ::T.untyped)
   OP_SAFARI_ECDHE_ECDSA_BUG = ::T.let(nil, ::T.untyped)
   OP_TLSEXT_PADDING = ::T.let(nil, ::T.untyped)
   SSL2_VERSION = ::T.let(nil, ::T.untyped)
   SSL3_VERSION = ::T.let(nil, ::T.untyped)
   TLS1_1_VERSION = ::T.let(nil, ::T.untyped)
   TLS1_2_VERSION = ::T.let(nil, ::T.untyped)
+  TLS1_3_VERSION = ::T.let(nil, ::T.untyped)
   TLS1_VERSION = ::T.let(nil, ::T.untyped)
 end
 
@@ -5551,2362 +6775,4032 @@ class OpenSSL::SSL::SSLContext
 
   def alpn_select_cb=(alpn_select_cb); end
 
+  def enable_fallback_scsv(); end
+
   def max_version=(version); end
 
   def min_version=(version); end
+
+  def tmp_dh=(tmp_dh); end
   DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped)
 end
 
 class OpenSSL::SSL::SSLSocket
   def alpn_protocol(); end
 
+  def finished_message(); end
+
+  def peer_finished_message(); end
+
   def tmp_key(); end
 end
 
-module OpenSSL::X509
-  V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped)
-  V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped)
+class OpenSSL::SSL::SSLSocket
+  def self.open(remote_host, remote_port, local_host=T.unsafe(nil), local_port=T.unsafe(nil), context: T.unsafe(nil)); end
 end
 
-class OpenSSL::X509::Attribute
-  def ==(other); end
+module OpenSSL::SSL::SocketForwarder
+  def fileno(); end
 end
 
-class OpenSSL::X509::CRL
-  def ==(other); end
+module OpenSSL::Timestamp
 end
 
-class OpenSSL::X509::Extension
-  def ==(other); end
-end
+class OpenSSL::Timestamp::Factory
+  def additional_certs(); end
 
-class OpenSSL::X509::Name
-  def to_utf8(); end
-end
+  def additional_certs=(additional_certs); end
 
-class OpenSSL::X509::Request
-  def ==(other); end
-end
+  def allowed_digests(); end
 
-class OpenSSL::X509::Revoked
-  def ==(other); end
+  def allowed_digests=(allowed_digests); end
 
-  def to_der(); end
-end
+  def create_timestamp(arg, arg1, arg2); end
 
-module OpenSSL
-  def self.fips_mode(); end
-end
+  def default_policy_id(); end
 
-module ParallelTests
-  WINDOWS = ::T.let(nil, ::T.untyped)
-end
+  def default_policy_id=(default_policy_id); end
 
-class Parlour::Conversion::Converter
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-end
+  def gen_time(); end
 
-module Parlour::Debugging
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
+  def gen_time=(gen_time); end
 
-module Parlour::Mixin::Searchable
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
+  def serial_number(); end
 
-class Parlour::Plugin
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
+  def serial_number=(serial_number); end
 end
 
-module Parlour::TypeLoader
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
+class OpenSSL::Timestamp::Factory
 end
 
-class Parlour::TypedObject
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-end
+class OpenSSL::Timestamp::Request
+  def algorithm(); end
 
-class Parlour::Types::Type
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-end
+  def algorithm=(algorithm); end
 
-class Parser::Ruby26
-  Racc_debug_parser = ::T.let(nil, ::T.untyped)
+  def cert_requested=(cert_requested); end
+
+  def cert_requested?(); end
+
+  def initialize(*arg); end
+
+  def message_imprint(); end
+
+  def message_imprint=(message_imprint); end
+
+  def nonce(); end
+
+  def nonce=(nonce); end
+
+  def policy_id(); end
+
+  def policy_id=(policy_id); end
+
+  def to_der(); end
+
+  def version(); end
+
+  def version=(version); end
 end
 
-module Predicable
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
+class OpenSSL::Timestamp::Request
 end
 
-class Proc
-  include ::MethodSource::SourceLocation::ProcExtensions
-  include ::MethodSource::MethodExtensions
-  def <<(arg); end
+class OpenSSL::Timestamp::Response
+  def failure_info(); end
 
-  def >>(arg); end
+  def initialize(arg); end
 
-  def clone(); end
-end
+  def status(); end
 
-module Process
-  def self.fork(); end
+  def status_text(); end
+
+  def to_der(); end
+
+  def token(); end
+
+  def token_info(); end
+
+  def tsa_certificate(); end
+
+  def verify(*arg); end
+  GRANTED = ::T.let(nil, ::T.untyped)
+  GRANTED_WITH_MODS = ::T.let(nil, ::T.untyped)
+  REJECTION = ::T.let(nil, ::T.untyped)
+  REVOCATION_NOTIFICATION = ::T.let(nil, ::T.untyped)
+  REVOCATION_WARNING = ::T.let(nil, ::T.untyped)
+  WAITING = ::T.let(nil, ::T.untyped)
 end
 
-class Pry::BasicObject
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::ActiveSupport::ForkTracker::CoreExt
+class OpenSSL::Timestamp::Response
 end
 
-module Psych
-  VERSION = ::T.let(nil, ::T.untyped)
+class OpenSSL::Timestamp::TimestampError
 end
 
-module Psych
-  def self.add_builtin_type(type_tag, &block); end
+class OpenSSL::Timestamp::TimestampError
+end
 
-  def self.add_domain_type(domain, type_tag, &block); end
+class OpenSSL::Timestamp::TokenInfo
+  def algorithm(); end
 
-  def self.add_tag(tag, klass); end
+  def gen_time(); end
 
-  def self.domain_types(); end
+  def initialize(arg); end
 
-  def self.domain_types=(domain_types); end
+  def message_imprint(); end
 
-  def self.dump_tags(); end
+  def nonce(); end
 
-  def self.dump_tags=(dump_tags); end
+  def ordering(); end
 
-  def self.libyaml_version(); end
+  def policy_id(); end
 
-  def self.load_tags(); end
+  def serial_number(); end
 
-  def self.load_tags=(load_tags); end
+  def to_der(); end
 
-  def self.remove_type(type_tag); end
+  def version(); end
 end
 
-module PyPI
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
+class OpenSSL::Timestamp::TokenInfo
 end
 
-class RBI::ASTVisitor
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
+module OpenSSL::Timestamp
 end
 
-class RBI::Index
-  include ::T::Enumerable
+module OpenSSL::X509
+  V_ERR_CA_KEY_TOO_SMALL = ::T.let(nil, ::T.untyped)
+  V_ERR_CA_MD_TOO_WEAK = ::T.let(nil, ::T.untyped)
+  V_ERR_CRL_PATH_VALIDATION_ERROR = ::T.let(nil, ::T.untyped)
+  V_ERR_DANE_NO_MATCH = ::T.let(nil, ::T.untyped)
+  V_ERR_DIFFERENT_CRL_SCOPE = ::T.let(nil, ::T.untyped)
+  V_ERR_EE_KEY_TOO_SMALL = ::T.let(nil, ::T.untyped)
+  V_ERR_EMAIL_MISMATCH = ::T.let(nil, ::T.untyped)
+  V_ERR_EXCLUDED_VIOLATION = ::T.let(nil, ::T.untyped)
+  V_ERR_HOSTNAME_MISMATCH = ::T.let(nil, ::T.untyped)
+  V_ERR_INVALID_CALL = ::T.let(nil, ::T.untyped)
+  V_ERR_INVALID_EXTENSION = ::T.let(nil, ::T.untyped)
+  V_ERR_INVALID_NON_CA = ::T.let(nil, ::T.untyped)
+  V_ERR_INVALID_POLICY_EXTENSION = ::T.let(nil, ::T.untyped)
+  V_ERR_IP_ADDRESS_MISMATCH = ::T.let(nil, ::T.untyped)
+  V_ERR_KEYUSAGE_NO_CRL_SIGN = ::T.let(nil, ::T.untyped)
+  V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE = ::T.let(nil, ::T.untyped)
+  V_ERR_NO_EXPLICIT_POLICY = ::T.let(nil, ::T.untyped)
+  V_ERR_NO_VALID_SCTS = ::T.let(nil, ::T.untyped)
+  V_ERR_OCSP_CERT_UNKNOWN = ::T.let(nil, ::T.untyped)
+  V_ERR_OCSP_VERIFY_FAILED = ::T.let(nil, ::T.untyped)
+  V_ERR_OCSP_VERIFY_NEEDED = ::T.let(nil, ::T.untyped)
+  V_ERR_PATH_LOOP = ::T.let(nil, ::T.untyped)
+  V_ERR_PERMITTED_VIOLATION = ::T.let(nil, ::T.untyped)
+  V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED = ::T.let(nil, ::T.untyped)
+  V_ERR_PROXY_PATH_LENGTH_EXCEEDED = ::T.let(nil, ::T.untyped)
+  V_ERR_PROXY_SUBJECT_NAME_VIOLATION = ::T.let(nil, ::T.untyped)
+  V_ERR_STORE_LOOKUP = ::T.let(nil, ::T.untyped)
+  V_ERR_SUBTREE_MINMAX = ::T.let(nil, ::T.untyped)
+  V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 = ::T.let(nil, ::T.untyped)
+  V_ERR_SUITE_B_INVALID_ALGORITHM = ::T.let(nil, ::T.untyped)
+  V_ERR_SUITE_B_INVALID_CURVE = ::T.let(nil, ::T.untyped)
+  V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM = ::T.let(nil, ::T.untyped)
+  V_ERR_SUITE_B_INVALID_VERSION = ::T.let(nil, ::T.untyped)
+  V_ERR_SUITE_B_LOS_NOT_ALLOWED = ::T.let(nil, ::T.untyped)
+  V_ERR_UNABLE_TO_GET_CRL_ISSUER = ::T.let(nil, ::T.untyped)
+  V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION = ::T.let(nil, ::T.untyped)
+  V_ERR_UNHANDLED_CRITICAL_EXTENSION = ::T.let(nil, ::T.untyped)
+  V_ERR_UNNESTED_RESOURCE = ::T.let(nil, ::T.untyped)
+  V_ERR_UNSPECIFIED = ::T.let(nil, ::T.untyped)
+  V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX = ::T.let(nil, ::T.untyped)
+  V_ERR_UNSUPPORTED_CONSTRAINT_TYPE = ::T.let(nil, ::T.untyped)
+  V_ERR_UNSUPPORTED_EXTENSION_FEATURE = ::T.let(nil, ::T.untyped)
+  V_ERR_UNSUPPORTED_NAME_SYNTAX = ::T.let(nil, ::T.untyped)
+  V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped)
+  V_FLAG_PARTIAL_CHAIN = ::T.let(nil, ::T.untyped)
+  V_FLAG_SUITEB_128_LOS = ::T.let(nil, ::T.untyped)
+  V_FLAG_SUITEB_128_LOS_ONLY = ::T.let(nil, ::T.untyped)
+  V_FLAG_SUITEB_192_LOS = ::T.let(nil, ::T.untyped)
+  V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped)
+  V_FLAG_USE_CHECK_TIME = ::T.let(nil, ::T.untyped)
 end
 
-module RBI::Indexable
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
+class OpenSSL::X509::Attribute
+  include ::OpenSSL::Marshal
+  def ==(other); end
 end
 
-class RBI::Node
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
+class OpenSSL::X509::Attribute
+  extend ::OpenSSL::Marshal::ClassMethods
 end
 
-class RBI::Visitor
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
+class OpenSSL::X509::CRL
+  include ::OpenSSL::Marshal
+  include ::OpenSSL::X509::Extension::AuthorityKeyIdentifier
+  include ::OpenSSL::X509::Extension::Helpers
+  def ==(other); end
 end
 
-class REXML::XPathParser
-  DEBUG = ::T.let(nil, ::T.untyped)
+class OpenSSL::X509::CRL
+  extend ::OpenSSL::Marshal::ClassMethods
 end
 
-class RSpec::Core::ExampleGroup
-  include ::RSpec::Core::MockingAdapters::RSpec
-  include ::RSpec::Mocks::ExampleMethods
-  include ::RSpec::Mocks::ArgumentMatchers
-  include ::RSpec::Mocks::ExampleMethods::ExpectHost
-  include ::RSpec::Matchers
+class OpenSSL::X509::Certificate
+  include ::OpenSSL::Marshal
+  include ::OpenSSL::X509::Extension::SubjectKeyIdentifier
+  include ::OpenSSL::X509::Extension::AuthorityKeyIdentifier
+  include ::OpenSSL::X509::Extension::CRLDistributionPoints
+  include ::OpenSSL::X509::Extension::AuthorityInfoAccess
+  include ::OpenSSL::X509::Extension::Helpers
 end
 
-module RSpec::Core::HashImitatable
-  def assert_valid_keys(*args, &block); end
+class OpenSSL::X509::Certificate
+  extend ::OpenSSL::Marshal::ClassMethods
+  def self.load(arg); end
 
-  def compact_blank(*args, &block); end
+  def self.load_file(path); end
+end
 
-  def compact_blank!(*args, &block); end
+class OpenSSL::X509::Extension
+  include ::OpenSSL::Marshal
+  def ==(other); end
 
-  def deep_stringify_keys(*args, &block); end
+  def value_der(); end
+end
 
-  def deep_stringify_keys!(*args, &block); end
+module OpenSSL::X509::Extension::AuthorityInfoAccess
+  include ::OpenSSL::X509::Extension::Helpers
+  def ca_issuer_uris(); end
 
-  def deep_symbolize_keys(*args, &block); end
+  def ocsp_uris(); end
+end
 
-  def deep_symbolize_keys!(*args, &block); end
+module OpenSSL::X509::Extension::AuthorityInfoAccess
+end
 
-  def deep_transform_keys(*args, &block); end
+module OpenSSL::X509::Extension::AuthorityKeyIdentifier
+  include ::OpenSSL::X509::Extension::Helpers
+  def authority_key_identifier(); end
+end
 
-  def deep_transform_keys!(*args, &block); end
+module OpenSSL::X509::Extension::AuthorityKeyIdentifier
+end
 
-  def exclude?(*args, &block); end
+module OpenSSL::X509::Extension::CRLDistributionPoints
+  include ::OpenSSL::X509::Extension::Helpers
+  def crl_uris(); end
+end
 
-  def excluding(*args, &block); end
+module OpenSSL::X509::Extension::CRLDistributionPoints
+end
 
-  def extractable_options?(*args, &block); end
+module OpenSSL::X509::Extension::Helpers
+  def find_extension(oid); end
+end
 
-  def including(*args, &block); end
+module OpenSSL::X509::Extension::Helpers
+end
 
-  def index_by(*args, &block); end
+module OpenSSL::X509::Extension::SubjectKeyIdentifier
+  include ::OpenSSL::X509::Extension::Helpers
+  def subject_key_identifier(); end
+end
 
-  def index_with(*args, &block); end
+module OpenSSL::X509::Extension::SubjectKeyIdentifier
+end
 
-  def many?(*args, &block); end
+class OpenSSL::X509::Extension
+  extend ::OpenSSL::Marshal::ClassMethods
+end
 
-  def pick(*args, &block); end
+class OpenSSL::X509::Name
+  include ::OpenSSL::Marshal
+  def to_utf8(); end
+end
 
-  def pluck(*args, &block); end
+class OpenSSL::X509::Name
+  extend ::OpenSSL::Marshal::ClassMethods
+end
 
-  def stringify_keys(*args, &block); end
+class OpenSSL::X509::Request
+  include ::OpenSSL::Marshal
+  def ==(other); end
+end
 
-  def stringify_keys!(*args, &block); end
+class OpenSSL::X509::Request
+  extend ::OpenSSL::Marshal::ClassMethods
+end
 
-  def symbolize_keys(*args, &block); end
+class OpenSSL::X509::Revoked
+  def ==(other); end
 
-  def symbolize_keys!(*args, &block); end
+  def to_der(); end
+end
 
-  def to_options(*args, &block); end
+module OpenSSL
+  def self.fips_mode(); end
 
-  def to_options!(*args, &block); end
+  def self.fixed_length_secure_compare(arg, arg1); end
 
-  def without(*args, &block); end
+  def self.secure_compare(a, b); end
 end
 
-module RSpec::Core::MockingAdapters
-end
+class OpenStruct
+  def __id__!(); end
 
-module RSpec::Core::MockingAdapters::RSpec
-  include ::RSpec::Mocks::ExampleMethods
-  include ::RSpec::Mocks::ArgumentMatchers
-  include ::RSpec::Mocks::ExampleMethods::ExpectHost
-  def setup_mocks_for_rspec(); end
+  def __send__!(*arg); end
 
-  def teardown_mocks_for_rspec(); end
+  def class!(); end
 
-  def verify_mocks_for_rspec(); end
-end
+  def clone!(freeze: T.unsafe(nil)); end
 
-module RSpec::Core::MockingAdapters::RSpec
-  def self.configuration(); end
+  def define_singleton_method!(*arg); end
 
-  def self.framework_name(); end
-end
+  def delete_field!(name); end
 
-module RSpec::Core::MockingAdapters
-end
+  def dig!(name, *names); end
 
-class RSpec::Core::OutputWrapper
-  def as_json(*args, &block); end
+  def display!(*arg); end
 
-  def readline_nonblock(*args, &block); end
-end
+  def dup!(); end
 
-class RSpec::Expectations::MultipleExpectationsNotMetError
-  include ::RSpec::Core::MultipleExceptionError::InterfaceTag
-end
+  def each_pair!(); end
 
-module RSpec::Sorbet::Doubles
-  extend ::T::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
+  def encode_with(coder); end
 
-module Racc
-  Racc_No_Extensions = ::T.let(nil, ::T.untyped)
-end
+  def encode_with!(coder); end
 
-class Racc::CparseParams
-end
+  def enum_for!(*arg); end
 
-class Racc::CparseParams
-end
+  def extend!(mod, *args); end
 
-class Random
-  def self.bytes(arg); end
-end
+  def freeze!(); end
 
-class Range
-  def %(arg); end
+  def gem!(dep, *reqs); end
 
-  def entries(); end
+  def hash!(); end
 
-  def to_a(); end
-end
+  def init_with(coder); end
 
-module RbConfig
-  def self.expand(val, config=T.unsafe(nil)); end
+  def init_with!(coder); end
 
-  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
+  def inspect!(); end
 
-  def self.ruby(); end
-end
+  def instance_eval!(*arg); end
 
-module Readline
-  def self.completion_quote_character(); end
-end
+  def instance_exec!(*arg); end
 
-class Requirements
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
+  def instance_variable_get!(arg); end
 
-class Resolv::DNS
-  def extract_resources(msg, name, typeclass); end
-  RequestID = ::T.let(nil, ::T.untyped)
-  RequestIDMutex = ::T.let(nil, ::T.untyped)
-end
+  def instance_variable_set!(arg, arg1); end
 
-class Resolv::DNS::Config
-  def initialize(config_info=T.unsafe(nil)); end
-end
+  def instance_variables!(); end
 
-class Resolv::DNS::Label::Str
-  def initialize(string); end
-end
+  def itself!(); end
 
-class Resolv::DNS::Message
-  def initialize(id=T.unsafe(nil)); end
-end
+  def marshal_dump!(); end
 
-class Resolv::DNS::Message::MessageDecoder
-  def initialize(data); end
-end
+  def method!(arg); end
 
-class Resolv::DNS::Requester::ConnectedUDP
-  def initialize(host, port=T.unsafe(nil)); end
+  def methods!(*arg); end
 
-  def lazy_initialize(); end
-end
+  def object_id!(); end
 
-class Resolv::DNS::Requester::Sender
-  def initialize(msg, data, sock); end
-end
+  def private_methods!(*arg); end
 
-class Resolv::DNS::Requester::TCP
-  def initialize(host, port=T.unsafe(nil)); end
-end
+  def protected_methods!(*arg); end
 
-class Resolv::DNS::Requester::UnconnectedUDP
-  def initialize(*nameserver_port); end
+  def public_method!(arg); end
 
-  def lazy_initialize(); end
-end
+  def public_methods!(*arg); end
 
-class Resolv::DNS::Requester::UnconnectedUDP::Sender
-  def initialize(msg, data, sock, host, port); end
-end
+  def public_send!(*arg); end
 
-class Resolv::DNS::Resource
-  ClassValue = ::T.let(nil, ::T.untyped)
-end
+  def remove_instance_variable!(arg); end
 
-class Resolv::DNS::Resource::LOC
-  def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude); end
-end
+  def send!(*arg); end
 
-class Resolv::DNS
-  def self.allocate_request_id(host, port); end
+  def singleton_class!(); end
 
-  def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end
+  def singleton_method!(arg); end
 
-  def self.free_request_id(host, port, id); end
+  def singleton_methods!(*arg); end
 
-  def self.random(arg); end
-end
+  def taint!(); end
 
-class Resource
-  include ::FileUtils::StreamUtils_
-  def on_arch_conditional(arm: T.unsafe(nil), intel: T.unsafe(nil)); end
+  def tap!(); end
 
-  def on_arm(&block); end
+  def then!(); end
 
-  def on_big_sur(or_condition=T.unsafe(nil), &block); end
+  def to_enum!(*arg); end
 
-  def on_catalina(or_condition=T.unsafe(nil), &block); end
+  def to_h!(&block); end
 
-  def on_el_capitan(or_condition=T.unsafe(nil), &block); end
+  def to_s!(); end
 
-  def on_high_sierra(or_condition=T.unsafe(nil), &block); end
+  def trust!(); end
 
-  def on_intel(&block); end
+  def untaint!(); end
 
-  def on_linux(&block); end
+  def untrust!(); end
 
-  def on_macos(&block); end
+  def yield_self!(); end
+  VERSION = ::T.let(nil, ::T.untyped)
+end
 
-  def on_mojave(or_condition=T.unsafe(nil), &block); end
+class OptionParser
+  def additional_message(typ, opt); end
 
-  def on_monterey(or_condition=T.unsafe(nil), &block); end
+  def require_exact(); end
 
-  def on_sierra(or_condition=T.unsafe(nil), &block); end
+  def require_exact=(require_exact); end
+  Version = ::T.let(nil, ::T.untyped)
+end
 
-  def on_sonoma(or_condition=T.unsafe(nil), &block); end
+class OptionParser::List
+  def get_candidates(id); end
+end
 
-  def on_system(linux, macos:, &block); end
+class OptionParser::ParseError
+  def additional(); end
 
-  def on_system_conditional(macos: T.unsafe(nil), linux: T.unsafe(nil)); end
+  def additional=(additional); end
+end
 
-  def on_ventura(or_condition=T.unsafe(nil), &block); end
+class PP
+  def self.width_for(out); end
 end
 
-class Resource::Partial
-  def self.[](*arg); end
+module ParallelTests
+  WINDOWS = ::T.let(nil, ::T.untyped)
+end
 
-  def self.members(); end
+class Parlour::Conversion::Converter
+  extend ::T::Helpers
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
 end
 
-class Ripper
-  def column(); end
+module Parlour::Debugging
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
 
-  def encoding(); end
+module Parlour::Mixin::Searchable
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
 
-  def end_seen?(); end
+class Parlour::Plugin
+  extend ::T::Helpers
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
+end
 
-  def error?(); end
+module Parlour::TypeLoader
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
 
-  def filename(); end
+class Parlour::TypedObject
+  extend ::T::Helpers
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
+end
 
-  def initialize(*arg); end
+class Parlour::Types::Type
+  extend ::T::Helpers
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
+end
 
-  def lineno(); end
+class Parser::Ruby31
+  def _reduce_1(val, _values, result); end
 
-  def parse(); end
+  def _reduce_10(val, _values, result); end
 
-  def state(); end
+  def _reduce_100(val, _values, result); end
 
-  def yydebug(); end
+  def _reduce_102(val, _values, result); end
 
-  def yydebug=(yydebug); end
-  EXPR_ARG = ::T.let(nil, ::T.untyped)
-  EXPR_ARG_ANY = ::T.let(nil, ::T.untyped)
-  EXPR_BEG = ::T.let(nil, ::T.untyped)
-  EXPR_BEG_ANY = ::T.let(nil, ::T.untyped)
-  EXPR_CLASS = ::T.let(nil, ::T.untyped)
-  EXPR_CMDARG = ::T.let(nil, ::T.untyped)
-  EXPR_DOT = ::T.let(nil, ::T.untyped)
-  EXPR_END = ::T.let(nil, ::T.untyped)
-  EXPR_ENDARG = ::T.let(nil, ::T.untyped)
-  EXPR_ENDFN = ::T.let(nil, ::T.untyped)
-  EXPR_END_ANY = ::T.let(nil, ::T.untyped)
-  EXPR_FITEM = ::T.let(nil, ::T.untyped)
-  EXPR_FNAME = ::T.let(nil, ::T.untyped)
-  EXPR_LABEL = ::T.let(nil, ::T.untyped)
-  EXPR_LABELED = ::T.let(nil, ::T.untyped)
-  EXPR_MID = ::T.let(nil, ::T.untyped)
-  EXPR_NONE = ::T.let(nil, ::T.untyped)
-  EXPR_VALUE = ::T.let(nil, ::T.untyped)
-  PARSER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
-  SCANNER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
-  Version = ::T.let(nil, ::T.untyped)
-end
+  def _reduce_103(val, _values, result); end
 
-class Ripper::Filter
-  def initialize(src, filename=T.unsafe(nil), lineno=T.unsafe(nil)); end
-end
+  def _reduce_104(val, _values, result); end
 
-class Ripper::Lexer
-  def lex(); end
+  def _reduce_105(val, _values, result); end
 
-  def tokenize(); end
-end
+  def _reduce_106(val, _values, result); end
 
-class Ripper::Lexer::Elem
-  def event(); end
+  def _reduce_107(val, _values, result); end
 
-  def event=(_); end
+  def _reduce_108(val, _values, result); end
 
-  def initialize(pos, event, tok, state); end
+  def _reduce_109(val, _values, result); end
 
-  def pos(); end
+  def _reduce_11(val, _values, result); end
 
-  def pos=(_); end
+  def _reduce_110(val, _values, result); end
 
-  def state(); end
+  def _reduce_111(val, _values, result); end
 
-  def state=(_); end
+  def _reduce_112(val, _values, result); end
 
-  def tok(); end
+  def _reduce_113(val, _values, result); end
 
-  def tok=(_); end
-end
+  def _reduce_114(val, _values, result); end
 
-class Ripper::Lexer::Elem
-  def self.[](*arg); end
+  def _reduce_115(val, _values, result); end
 
-  def self.members(); end
-end
+  def _reduce_116(val, _values, result); end
 
-class Ripper::Lexer::State
-  def &(i); end
+  def _reduce_117(val, _values, result); end
 
-  def ==(i); end
+  def _reduce_118(val, _values, result); end
 
-  def allbits?(i); end
+  def _reduce_119(val, _values, result); end
 
-  def anybits?(i); end
+  def _reduce_12(val, _values, result); end
 
-  def initialize(i); end
+  def _reduce_120(val, _values, result); end
 
-  def nobits?(i); end
+  def _reduce_121(val, _values, result); end
 
-  def to_i(); end
+  def _reduce_122(val, _values, result); end
 
-  def to_int(); end
+  def _reduce_123(val, _values, result); end
 
-  def to_int=(_); end
+  def _reduce_124(val, _values, result); end
 
-  def to_s=(_); end
+  def _reduce_125(val, _values, result); end
 
-  def |(i); end
-end
+  def _reduce_127(val, _values, result); end
 
-class Ripper::Lexer::State
-  def self.[](*arg); end
+  def _reduce_128(val, _values, result); end
 
-  def self.members(); end
-end
+  def _reduce_129(val, _values, result); end
 
-class Ripper::Lexer
-end
+  def _reduce_13(val, _values, result); end
 
-class Ripper::SexpBuilder
-  def on_BEGIN(*args); end
+  def _reduce_135(val, _values, result); end
 
-  def on_CHAR(tok); end
+  def _reduce_137(val, _values, result); end
 
-  def on_END(*args); end
+  def _reduce_138(val, _values, result); end
 
-  def on___end__(tok); end
+  def _reduce_139(val, _values, result); end
 
-  def on_alias(*args); end
+  def _reduce_14(val, _values, result); end
 
-  def on_alias_error(*args); end
+  def _reduce_15(val, _values, result); end
 
-  def on_aref(*args); end
+  def _reduce_16(val, _values, result); end
 
-  def on_aref_field(*args); end
+  def _reduce_18(val, _values, result); end
 
-  def on_arg_ambiguous(*args); end
+  def _reduce_19(val, _values, result); end
 
-  def on_arg_paren(*args); end
+  def _reduce_2(val, _values, result); end
 
-  def on_args_add(*args); end
+  def _reduce_20(val, _values, result); end
 
-  def on_args_add_block(*args); end
+  def _reduce_21(val, _values, result); end
 
-  def on_args_add_star(*args); end
+  def _reduce_211(val, _values, result); end
 
-  def on_args_new(*args); end
+  def _reduce_212(val, _values, result); end
 
-  def on_array(*args); end
+  def _reduce_213(val, _values, result); end
 
-  def on_assign(*args); end
+  def _reduce_214(val, _values, result); end
 
-  def on_assign_error(*args); end
+  def _reduce_215(val, _values, result); end
 
-  def on_assoc_new(*args); end
+  def _reduce_216(val, _values, result); end
 
-  def on_assoc_splat(*args); end
+  def _reduce_217(val, _values, result); end
 
-  def on_assoclist_from_args(*args); end
+  def _reduce_218(val, _values, result); end
 
-  def on_backref(tok); end
+  def _reduce_219(val, _values, result); end
 
-  def on_backtick(tok); end
+  def _reduce_22(val, _values, result); end
 
-  def on_bare_assoc_hash(*args); end
+  def _reduce_220(val, _values, result); end
 
-  def on_begin(*args); end
+  def _reduce_221(val, _values, result); end
 
-  def on_binary(*args); end
+  def _reduce_222(val, _values, result); end
 
-  def on_block_var(*args); end
+  def _reduce_223(val, _values, result); end
 
-  def on_blockarg(*args); end
+  def _reduce_224(val, _values, result); end
 
-  def on_bodystmt(*args); end
+  def _reduce_225(val, _values, result); end
 
-  def on_brace_block(*args); end
+  def _reduce_226(val, _values, result); end
 
-  def on_break(*args); end
+  def _reduce_227(val, _values, result); end
 
-  def on_call(*args); end
+  def _reduce_228(val, _values, result); end
 
-  def on_case(*args); end
+  def _reduce_229(val, _values, result); end
 
-  def on_class(*args); end
+  def _reduce_23(val, _values, result); end
 
-  def on_class_name_error(*args); end
+  def _reduce_230(val, _values, result); end
 
-  def on_comma(tok); end
+  def _reduce_231(val, _values, result); end
 
-  def on_command(*args); end
+  def _reduce_232(val, _values, result); end
 
-  def on_command_call(*args); end
+  def _reduce_233(val, _values, result); end
 
-  def on_comment(tok); end
+  def _reduce_234(val, _values, result); end
 
-  def on_const(tok); end
+  def _reduce_235(val, _values, result); end
 
-  def on_const_path_field(*args); end
+  def _reduce_236(val, _values, result); end
 
-  def on_const_path_ref(*args); end
+  def _reduce_237(val, _values, result); end
 
-  def on_const_ref(*args); end
+  def _reduce_238(val, _values, result); end
 
-  def on_cvar(tok); end
+  def _reduce_24(val, _values, result); end
 
-  def on_def(*args); end
+  def _reduce_240(val, _values, result); end
 
-  def on_defined(*args); end
+  def _reduce_241(val, _values, result); end
 
-  def on_defs(*args); end
+  def _reduce_242(val, _values, result); end
 
-  def on_do_block(*args); end
+  def _reduce_243(val, _values, result); end
 
-  def on_dot2(*args); end
+  def _reduce_244(val, _values, result); end
 
-  def on_dot3(*args); end
+  def _reduce_245(val, _values, result); end
 
-  def on_dyna_symbol(*args); end
+  def _reduce_246(val, _values, result); end
 
-  def on_else(*args); end
+  def _reduce_247(val, _values, result); end
 
-  def on_elsif(*args); end
+  def _reduce_248(val, _values, result); end
 
-  def on_embdoc(tok); end
+  def _reduce_249(val, _values, result); end
 
-  def on_embdoc_beg(tok); end
+  def _reduce_25(val, _values, result); end
 
-  def on_embdoc_end(tok); end
+  def _reduce_250(val, _values, result); end
 
-  def on_embexpr_beg(tok); end
+  def _reduce_251(val, _values, result); end
 
-  def on_embexpr_end(tok); end
+  def _reduce_252(val, _values, result); end
 
-  def on_embvar(tok); end
+  def _reduce_253(val, _values, result); end
 
-  def on_ensure(*args); end
+  def _reduce_254(val, _values, result); end
 
-  def on_excessed_comma(*args); end
+  def _reduce_255(val, _values, result); end
 
-  def on_fcall(*args); end
+  def _reduce_256(val, _values, result); end
 
-  def on_field(*args); end
+  def _reduce_257(val, _values, result); end
 
-  def on_float(tok); end
+  def _reduce_26(val, _values, result); end
 
-  def on_for(*args); end
+  def _reduce_263(val, _values, result); end
 
-  def on_gvar(tok); end
+  def _reduce_264(val, _values, result); end
 
-  def on_hash(*args); end
+  def _reduce_268(val, _values, result); end
 
-  def on_heredoc_beg(tok); end
+  def _reduce_269(val, _values, result); end
 
-  def on_heredoc_end(tok); end
+  def _reduce_27(val, _values, result); end
 
-  def on_ident(tok); end
+  def _reduce_271(val, _values, result); end
 
-  def on_if(*args); end
+  def _reduce_272(val, _values, result); end
 
-  def on_if_mod(*args); end
+  def _reduce_273(val, _values, result); end
 
-  def on_ifop(*args); end
+  def _reduce_274(val, _values, result); end
 
-  def on_ignored_nl(tok); end
+  def _reduce_275(val, _values, result); end
 
-  def on_ignored_sp(tok); end
+  def _reduce_277(val, _values, result); end
 
-  def on_imaginary(tok); end
+  def _reduce_28(val, _values, result); end
 
-  def on_int(tok); end
+  def _reduce_280(val, _values, result); end
 
-  def on_ivar(tok); end
+  def _reduce_281(val, _values, result); end
 
-  def on_kw(tok); end
+  def _reduce_282(val, _values, result); end
 
-  def on_kwrest_param(*args); end
+  def _reduce_283(val, _values, result); end
 
-  def on_label(tok); end
+  def _reduce_284(val, _values, result); end
 
-  def on_label_end(tok); end
+  def _reduce_285(val, _values, result); end
 
-  def on_lambda(*args); end
+  def _reduce_286(val, _values, result); end
 
-  def on_lbrace(tok); end
+  def _reduce_287(val, _values, result); end
 
-  def on_lbracket(tok); end
+  def _reduce_288(val, _values, result); end
 
-  def on_lparen(tok); end
+  def _reduce_289(val, _values, result); end
 
-  def on_magic_comment(*args); end
+  def _reduce_29(val, _values, result); end
 
-  def on_massign(*args); end
+  def _reduce_290(val, _values, result); end
 
-  def on_method_add_arg(*args); end
+  def _reduce_291(val, _values, result); end
 
-  def on_method_add_block(*args); end
+  def _reduce_292(val, _values, result); end
 
-  def on_mlhs_add(*args); end
+  def _reduce_293(val, _values, result); end
 
-  def on_mlhs_add_post(*args); end
+  def _reduce_294(val, _values, result); end
 
-  def on_mlhs_add_star(*args); end
+  def _reduce_295(val, _values, result); end
 
-  def on_mlhs_new(*args); end
+  def _reduce_296(val, _values, result); end
 
-  def on_mlhs_paren(*args); end
+  def _reduce_297(val, _values, result); end
 
-  def on_module(*args); end
+  def _reduce_299(val, _values, result); end
 
-  def on_mrhs_add(*args); end
+  def _reduce_3(val, _values, result); end
 
-  def on_mrhs_add_star(*args); end
+  def _reduce_30(val, _values, result); end
 
-  def on_mrhs_new(*args); end
+  def _reduce_300(val, _values, result); end
 
-  def on_mrhs_new_from_args(*args); end
+  def _reduce_301(val, _values, result); end
 
-  def on_next(*args); end
+  def _reduce_312(val, _values, result); end
 
-  def on_nl(tok); end
+  def _reduce_313(val, _values, result); end
 
-  def on_op(tok); end
+  def _reduce_314(val, _values, result); end
 
-  def on_opassign(*args); end
+  def _reduce_315(val, _values, result); end
 
-  def on_operator_ambiguous(*args); end
+  def _reduce_316(val, _values, result); end
 
-  def on_param_error(*args); end
+  def _reduce_317(val, _values, result); end
 
-  def on_params(*args); end
+  def _reduce_318(val, _values, result); end
 
-  def on_paren(*args); end
+  def _reduce_319(val, _values, result); end
 
-  def on_parse_error(*args); end
+  def _reduce_32(val, _values, result); end
 
-  def on_period(tok); end
+  def _reduce_320(val, _values, result); end
 
-  def on_program(*args); end
+  def _reduce_321(val, _values, result); end
 
-  def on_qsymbols_add(*args); end
+  def _reduce_322(val, _values, result); end
 
-  def on_qsymbols_beg(tok); end
+  def _reduce_323(val, _values, result); end
 
-  def on_qsymbols_new(*args); end
+  def _reduce_324(val, _values, result); end
 
-  def on_qwords_add(*args); end
+  def _reduce_325(val, _values, result); end
 
-  def on_qwords_beg(tok); end
+  def _reduce_326(val, _values, result); end
 
-  def on_qwords_new(*args); end
+  def _reduce_327(val, _values, result); end
 
-  def on_rational(tok); end
+  def _reduce_328(val, _values, result); end
 
-  def on_rbrace(tok); end
+  def _reduce_329(val, _values, result); end
 
-  def on_rbracket(tok); end
+  def _reduce_33(val, _values, result); end
 
-  def on_redo(*args); end
+  def _reduce_330(val, _values, result); end
 
-  def on_regexp_add(*args); end
+  def _reduce_331(val, _values, result); end
 
-  def on_regexp_beg(tok); end
+  def _reduce_332(val, _values, result); end
 
-  def on_regexp_end(tok); end
+  def _reduce_334(val, _values, result); end
 
-  def on_regexp_literal(*args); end
+  def _reduce_336(val, _values, result); end
 
-  def on_regexp_new(*args); end
+  def _reduce_337(val, _values, result); end
 
-  def on_rescue(*args); end
+  def _reduce_338(val, _values, result); end
 
-  def on_rescue_mod(*args); end
+  def _reduce_339(val, _values, result); end
 
-  def on_rest_param(*args); end
+  def _reduce_34(val, _values, result); end
 
-  def on_retry(*args); end
+  def _reduce_340(val, _values, result); end
 
-  def on_return(*args); end
+  def _reduce_341(val, _values, result); end
 
-  def on_return0(*args); end
+  def _reduce_342(val, _values, result); end
 
-  def on_rparen(tok); end
+  def _reduce_343(val, _values, result); end
 
-  def on_sclass(*args); end
+  def _reduce_344(val, _values, result); end
 
-  def on_semicolon(tok); end
+  def _reduce_345(val, _values, result); end
 
-  def on_sp(tok); end
+  def _reduce_346(val, _values, result); end
 
-  def on_stmts_add(*args); end
+  def _reduce_347(val, _values, result); end
 
-  def on_stmts_new(*args); end
+  def _reduce_348(val, _values, result); end
 
-  def on_string_add(*args); end
+  def _reduce_349(val, _values, result); end
 
-  def on_string_concat(*args); end
+  def _reduce_35(val, _values, result); end
 
-  def on_string_content(*args); end
+  def _reduce_350(val, _values, result); end
 
-  def on_string_dvar(*args); end
+  def _reduce_351(val, _values, result); end
 
-  def on_string_embexpr(*args); end
+  def _reduce_352(val, _values, result); end
 
-  def on_string_literal(*args); end
+  def _reduce_353(val, _values, result); end
 
-  def on_super(*args); end
+  def _reduce_354(val, _values, result); end
 
-  def on_symbeg(tok); end
+  def _reduce_355(val, _values, result); end
 
-  def on_symbol(*args); end
+  def _reduce_357(val, _values, result); end
 
-  def on_symbol_literal(*args); end
+  def _reduce_358(val, _values, result); end
 
-  def on_symbols_add(*args); end
+  def _reduce_359(val, _values, result); end
 
-  def on_symbols_beg(tok); end
+  def _reduce_360(val, _values, result); end
 
-  def on_symbols_new(*args); end
+  def _reduce_363(val, _values, result); end
 
-  def on_tlambda(tok); end
+  def _reduce_367(val, _values, result); end
 
-  def on_tlambeg(tok); end
+  def _reduce_369(val, _values, result); end
 
-  def on_top_const_field(*args); end
+  def _reduce_37(val, _values, result); end
 
-  def on_top_const_ref(*args); end
+  def _reduce_372(val, _values, result); end
 
-  def on_tstring_beg(tok); end
+  def _reduce_373(val, _values, result); end
 
-  def on_tstring_content(tok); end
+  def _reduce_374(val, _values, result); end
 
-  def on_tstring_end(tok); end
+  def _reduce_375(val, _values, result); end
 
-  def on_unary(*args); end
+  def _reduce_377(val, _values, result); end
 
-  def on_undef(*args); end
+  def _reduce_378(val, _values, result); end
 
-  def on_unless(*args); end
+  def _reduce_379(val, _values, result); end
 
-  def on_unless_mod(*args); end
+  def _reduce_38(val, _values, result); end
 
-  def on_until(*args); end
+  def _reduce_380(val, _values, result); end
 
-  def on_until_mod(*args); end
+  def _reduce_381(val, _values, result); end
 
-  def on_var_alias(*args); end
+  def _reduce_382(val, _values, result); end
 
-  def on_var_field(*args); end
+  def _reduce_385(val, _values, result); end
 
-  def on_var_ref(*args); end
+  def _reduce_386(val, _values, result); end
 
-  def on_vcall(*args); end
+  def _reduce_387(val, _values, result); end
 
-  def on_void_stmt(*args); end
+  def _reduce_388(val, _values, result); end
 
-  def on_when(*args); end
+  def _reduce_389(val, _values, result); end
 
-  def on_while(*args); end
+  def _reduce_39(val, _values, result); end
 
-  def on_while_mod(*args); end
+  def _reduce_390(val, _values, result); end
 
-  def on_word_add(*args); end
+  def _reduce_391(val, _values, result); end
 
-  def on_word_new(*args); end
+  def _reduce_392(val, _values, result); end
 
-  def on_words_add(*args); end
+  def _reduce_394(val, _values, result); end
 
-  def on_words_beg(tok); end
+  def _reduce_395(val, _values, result); end
 
-  def on_words_new(*args); end
+  def _reduce_396(val, _values, result); end
 
-  def on_words_sep(tok); end
+  def _reduce_397(val, _values, result); end
 
-  def on_xstring_add(*args); end
+  def _reduce_398(val, _values, result); end
 
-  def on_xstring_literal(*args); end
+  def _reduce_4(val, _values, result); end
 
-  def on_xstring_new(*args); end
+  def _reduce_40(val, _values, result); end
 
-  def on_yield(*args); end
+  def _reduce_400(val, _values, result); end
 
-  def on_yield0(*args); end
+  def _reduce_401(val, _values, result); end
 
-  def on_zsuper(*args); end
-end
+  def _reduce_402(val, _values, result); end
 
-class Ripper::TokenPattern
-  def initialize(pattern); end
+  def _reduce_403(val, _values, result); end
 
-  def match(str); end
+  def _reduce_404(val, _values, result); end
 
-  def match_list(tokens); end
-  MAP = ::T.let(nil, ::T.untyped)
-end
+  def _reduce_405(val, _values, result); end
 
-class Ripper::TokenPattern::CompileError
-end
+  def _reduce_406(val, _values, result); end
 
-class Ripper::TokenPattern::CompileError
-end
+  def _reduce_407(val, _values, result); end
 
-class Ripper::TokenPattern::Error
-end
+  def _reduce_409(val, _values, result); end
 
-class Ripper::TokenPattern::Error
-end
+  def _reduce_41(val, _values, result); end
 
-class Ripper::TokenPattern::MatchData
-  def initialize(tokens, match); end
+  def _reduce_410(val, _values, result); end
 
-  def string(n=T.unsafe(nil)); end
-end
+  def _reduce_411(val, _values, result); end
 
-class Ripper::TokenPattern::MatchData
-end
+  def _reduce_412(val, _values, result); end
 
-class Ripper::TokenPattern::MatchError
-end
+  def _reduce_413(val, _values, result); end
 
-class Ripper::TokenPattern::MatchError
-end
+  def _reduce_414(val, _values, result); end
 
-class Ripper::TokenPattern
-  def self.compile(*arg); end
-end
+  def _reduce_415(val, _values, result); end
 
-class Ripper
-  def self.dedent_string(arg, arg1); end
+  def _reduce_416(val, _values, result); end
 
-  def self.lex_state_name(arg); end
+  def _reduce_417(val, _values, result); end
 
-  def self.token_match(src, pattern); end
-end
+  def _reduce_419(val, _values, result); end
 
-module RuboCop::AST::CollectionNode
-  def compact_blank(*args, &block); end
+  def _reduce_42(val, _values, result); end
 
-  def compact_blank!(*args, &block); end
+  def _reduce_420(val, _values, result); end
 
-  def exclude?(*args, &block); end
+  def _reduce_421(val, _values, result); end
 
-  def excluding(*args, &block); end
+  def _reduce_422(val, _values, result); end
 
-  def extract_options!(*args, &block); end
+  def _reduce_423(val, _values, result); end
 
-  def fifth(*args, &block); end
+  def _reduce_424(val, _values, result); end
 
-  def forty_two(*args, &block); end
+  def _reduce_425(val, _values, result); end
 
-  def fourth(*args, &block); end
+  def _reduce_426(val, _values, result); end
 
-  def from(*args, &block); end
+  def _reduce_427(val, _values, result); end
 
-  def including(*args, &block); end
+  def _reduce_428(val, _values, result); end
 
-  def index_by(*args, &block); end
+  def _reduce_429(val, _values, result); end
 
-  def index_with(*args, &block); end
+  def _reduce_43(val, _values, result); end
 
-  def many?(*args, &block); end
+  def _reduce_430(val, _values, result); end
 
-  def pick(*args, &block); end
+  def _reduce_431(val, _values, result); end
 
-  def pluck(*args, &block); end
+  def _reduce_432(val, _values, result); end
 
-  def second(*args, &block); end
+  def _reduce_433(val, _values, result); end
 
-  def second_to_last(*args, &block); end
+  def _reduce_434(val, _values, result); end
 
-  def third(*args, &block); end
+  def _reduce_435(val, _values, result); end
 
-  def third_to_last(*args, &block); end
+  def _reduce_436(val, _values, result); end
 
-  def to(*args, &block); end
+  def _reduce_437(val, _values, result); end
 
-  def to_default_s(*args, &block); end
+  def _reduce_438(val, _values, result); end
 
-  def to_formatted_s(*args, &block); end
+  def _reduce_439(val, _values, result); end
 
-  def to_sentence(*args, &block); end
+  def _reduce_44(val, _values, result); end
 
-  def to_xml(*args, &block); end
+  def _reduce_440(val, _values, result); end
 
-  def without(*args, &block); end
-end
+  def _reduce_441(val, _values, result); end
 
-class RuboCop::AST::Node
-  def arch_variable?(param0=T.unsafe(nil)); end
+  def _reduce_442(val, _values, result); end
 
-  def begin_block?(param0=T.unsafe(nil)); end
+  def _reduce_443(val, _values, result); end
 
-  def block_args(param0=T.unsafe(nil)); end
+  def _reduce_444(val, _values, result); end
 
-  def block_body(param0=T.unsafe(nil)); end
+  def _reduce_445(val, _values, result); end
 
-  def cask_block?(param0=T.unsafe(nil)); end
+  def _reduce_446(val, _values, result); end
 
-  def key_node(param0=T.unsafe(nil)); end
+  def _reduce_447(val, _values, result); end
 
-  def method_node(param0=T.unsafe(nil)); end
+  def _reduce_448(val, _values, result); end
 
-  def on_system_block?(param0=T.unsafe(nil)); end
+  def _reduce_449(val, _values, result); end
 
-  def val_node(param0=T.unsafe(nil)); end
-end
+  def _reduce_45(val, _values, result); end
 
-class RuboCop::AST::NodePattern::Parser
-  Racc_debug_parser = ::T.let(nil, ::T.untyped)
-end
+  def _reduce_450(val, _values, result); end
 
-module RuboCop::AST::NodePattern::Sets
-  SET_ARM_INTEL = ::T.let(nil, ::T.untyped)
-  SET_BASH_COMPLETION_ZSH_COMPLETION_FISH_COMPLETION = ::T.let(nil, ::T.untyped)
-  SET_BUILD_RECOMMENDED_TEST_OPTIONAL = ::T.let(nil, ::T.untyped)
-  SET_DEPENDS_ON_USES_FROM_MACOS = ::T.let(nil, ::T.untyped)
-  SET_INCLUDE_WITH_WITHOUT = ::T.let(nil, ::T.untyped)
-  SET_MAC_LINUX = ::T.let(nil, ::T.untyped)
-  SET_ON_ARM_ON_INTEL_ON_SONOMA_ETC = ::T.let(nil, ::T.untyped)
-  SET_ON_INTEL_ON_ARM = ::T.let(nil, ::T.untyped)
-  SET_OR_NEWER_OR_OLDER = ::T.let(nil, ::T.untyped)
-  SET_SYSTEM_SHELL_OUTPUT_PIPE_OUTPUT = ::T.let(nil, ::T.untyped)
-  SET_WITH_WITHOUT = ::T.let(nil, ::T.untyped)
-  SET____ETC_4 = ::T.let(nil, ::T.untyped)
+  def _reduce_451(val, _values, result); end
+
+  def _reduce_452(val, _values, result); end
+
+  def _reduce_453(val, _values, result); end
+
+  def _reduce_455(val, _values, result); end
+
+  def _reduce_456(val, _values, result); end
+
+  def _reduce_457(val, _values, result); end
+
+  def _reduce_458(val, _values, result); end
+
+  def _reduce_46(val, _values, result); end
+
+  def _reduce_460(val, _values, result); end
+
+  def _reduce_461(val, _values, result); end
+
+  def _reduce_462(val, _values, result); end
+
+  def _reduce_464(val, _values, result); end
+
+  def _reduce_465(val, _values, result); end
+
+  def _reduce_466(val, _values, result); end
+
+  def _reduce_467(val, _values, result); end
+
+  def _reduce_468(val, _values, result); end
+
+  def _reduce_47(val, _values, result); end
+
+  def _reduce_470(val, _values, result); end
+
+  def _reduce_472(val, _values, result); end
+
+  def _reduce_474(val, _values, result); end
+
+  def _reduce_475(val, _values, result); end
+
+  def _reduce_478(val, _values, result); end
+
+  def _reduce_479(val, _values, result); end
+
+  def _reduce_48(val, _values, result); end
+
+  def _reduce_480(val, _values, result); end
+
+  def _reduce_481(val, _values, result); end
+
+  def _reduce_482(val, _values, result); end
+
+  def _reduce_483(val, _values, result); end
+
+  def _reduce_484(val, _values, result); end
+
+  def _reduce_485(val, _values, result); end
+
+  def _reduce_486(val, _values, result); end
+
+  def _reduce_487(val, _values, result); end
+
+  def _reduce_488(val, _values, result); end
+
+  def _reduce_489(val, _values, result); end
+
+  def _reduce_490(val, _values, result); end
+
+  def _reduce_491(val, _values, result); end
+
+  def _reduce_492(val, _values, result); end
+
+  def _reduce_493(val, _values, result); end
+
+  def _reduce_494(val, _values, result); end
+
+  def _reduce_495(val, _values, result); end
+
+  def _reduce_496(val, _values, result); end
+
+  def _reduce_497(val, _values, result); end
+
+  def _reduce_498(val, _values, result); end
+
+  def _reduce_499(val, _values, result); end
+
+  def _reduce_5(val, _values, result); end
+
+  def _reduce_50(val, _values, result); end
+
+  def _reduce_500(val, _values, result); end
+
+  def _reduce_502(val, _values, result); end
+
+  def _reduce_503(val, _values, result); end
+
+  def _reduce_504(val, _values, result); end
+
+  def _reduce_505(val, _values, result); end
+
+  def _reduce_506(val, _values, result); end
+
+  def _reduce_507(val, _values, result); end
+
+  def _reduce_508(val, _values, result); end
+
+  def _reduce_509(val, _values, result); end
+
+  def _reduce_510(val, _values, result); end
+
+  def _reduce_512(val, _values, result); end
+
+  def _reduce_513(val, _values, result); end
+
+  def _reduce_514(val, _values, result); end
+
+  def _reduce_515(val, _values, result); end
+
+  def _reduce_516(val, _values, result); end
+
+  def _reduce_517(val, _values, result); end
+
+  def _reduce_518(val, _values, result); end
+
+  def _reduce_519(val, _values, result); end
+
+  def _reduce_520(val, _values, result); end
+
+  def _reduce_521(val, _values, result); end
+
+  def _reduce_522(val, _values, result); end
+
+  def _reduce_523(val, _values, result); end
+
+  def _reduce_524(val, _values, result); end
+
+  def _reduce_528(val, _values, result); end
+
+  def _reduce_529(val, _values, result); end
+
+  def _reduce_53(val, _values, result); end
+
+  def _reduce_530(val, _values, result); end
+
+  def _reduce_531(val, _values, result); end
+
+  def _reduce_535(val, _values, result); end
+
+  def _reduce_536(val, _values, result); end
+
+  def _reduce_54(val, _values, result); end
+
+  def _reduce_545(val, _values, result); end
+
+  def _reduce_547(val, _values, result); end
+
+  def _reduce_548(val, _values, result); end
+
+  def _reduce_549(val, _values, result); end
+
+  def _reduce_55(val, _values, result); end
+
+  def _reduce_550(val, _values, result); end
+
+  def _reduce_551(val, _values, result); end
+
+  def _reduce_552(val, _values, result); end
+
+  def _reduce_553(val, _values, result); end
+
+  def _reduce_554(val, _values, result); end
+
+  def _reduce_555(val, _values, result); end
+
+  def _reduce_556(val, _values, result); end
+
+  def _reduce_559(val, _values, result); end
+
+  def _reduce_56(val, _values, result); end
+
+  def _reduce_561(val, _values, result); end
+
+  def _reduce_565(val, _values, result); end
+
+  def _reduce_566(val, _values, result); end
+
+  def _reduce_567(val, _values, result); end
+
+  def _reduce_568(val, _values, result); end
+
+  def _reduce_569(val, _values, result); end
+
+  def _reduce_57(val, _values, result); end
+
+  def _reduce_570(val, _values, result); end
+
+  def _reduce_571(val, _values, result); end
+
+  def _reduce_572(val, _values, result); end
+
+  def _reduce_573(val, _values, result); end
+
+  def _reduce_574(val, _values, result); end
+
+  def _reduce_575(val, _values, result); end
+
+  def _reduce_576(val, _values, result); end
+
+  def _reduce_577(val, _values, result); end
+
+  def _reduce_578(val, _values, result); end
+
+  def _reduce_579(val, _values, result); end
+
+  def _reduce_58(val, _values, result); end
+
+  def _reduce_580(val, _values, result); end
+
+  def _reduce_581(val, _values, result); end
+
+  def _reduce_582(val, _values, result); end
+
+  def _reduce_583(val, _values, result); end
+
+  def _reduce_584(val, _values, result); end
+
+  def _reduce_585(val, _values, result); end
+
+  def _reduce_586(val, _values, result); end
+
+  def _reduce_587(val, _values, result); end
+
+  def _reduce_588(val, _values, result); end
+
+  def _reduce_589(val, _values, result); end
+
+  def _reduce_59(val, _values, result); end
+
+  def _reduce_590(val, _values, result); end
+
+  def _reduce_591(val, _values, result); end
+
+  def _reduce_592(val, _values, result); end
+
+  def _reduce_593(val, _values, result); end
+
+  def _reduce_594(val, _values, result); end
+
+  def _reduce_595(val, _values, result); end
+
+  def _reduce_596(val, _values, result); end
+
+  def _reduce_597(val, _values, result); end
+
+  def _reduce_598(val, _values, result); end
+
+  def _reduce_599(val, _values, result); end
+
+  def _reduce_6(val, _values, result); end
+
+  def _reduce_60(val, _values, result); end
+
+  def _reduce_603(val, _values, result); end
+
+  def _reduce_604(val, _values, result); end
+
+  def _reduce_605(val, _values, result); end
+
+  def _reduce_606(val, _values, result); end
+
+  def _reduce_607(val, _values, result); end
+
+  def _reduce_608(val, _values, result); end
+
+  def _reduce_609(val, _values, result); end
+
+  def _reduce_610(val, _values, result); end
+
+  def _reduce_611(val, _values, result); end
+
+  def _reduce_612(val, _values, result); end
+
+  def _reduce_613(val, _values, result); end
+
+  def _reduce_614(val, _values, result); end
+
+  def _reduce_615(val, _values, result); end
+
+  def _reduce_616(val, _values, result); end
+
+  def _reduce_617(val, _values, result); end
+
+  def _reduce_618(val, _values, result); end
+
+  def _reduce_619(val, _values, result); end
+
+  def _reduce_620(val, _values, result); end
+
+  def _reduce_621(val, _values, result); end
+
+  def _reduce_622(val, _values, result); end
+
+  def _reduce_623(val, _values, result); end
+
+  def _reduce_624(val, _values, result); end
+
+  def _reduce_625(val, _values, result); end
+
+  def _reduce_626(val, _values, result); end
+
+  def _reduce_627(val, _values, result); end
+
+  def _reduce_628(val, _values, result); end
+
+  def _reduce_629(val, _values, result); end
+
+  def _reduce_63(val, _values, result); end
+
+  def _reduce_630(val, _values, result); end
+
+  def _reduce_631(val, _values, result); end
+
+  def _reduce_632(val, _values, result); end
+
+  def _reduce_633(val, _values, result); end
+
+  def _reduce_634(val, _values, result); end
+
+  def _reduce_636(val, _values, result); end
+
+  def _reduce_637(val, _values, result); end
+
+  def _reduce_639(val, _values, result); end
+
+  def _reduce_64(val, _values, result); end
+
+  def _reduce_640(val, _values, result); end
+
+  def _reduce_641(val, _values, result); end
+
+  def _reduce_642(val, _values, result); end
+
+  def _reduce_643(val, _values, result); end
+
+  def _reduce_644(val, _values, result); end
+
+  def _reduce_645(val, _values, result); end
+
+  def _reduce_646(val, _values, result); end
+
+  def _reduce_647(val, _values, result); end
+
+  def _reduce_648(val, _values, result); end
+
+  def _reduce_649(val, _values, result); end
+
+  def _reduce_65(val, _values, result); end
+
+  def _reduce_650(val, _values, result); end
+
+  def _reduce_651(val, _values, result); end
+
+  def _reduce_652(val, _values, result); end
+
+  def _reduce_653(val, _values, result); end
+
+  def _reduce_654(val, _values, result); end
+
+  def _reduce_655(val, _values, result); end
+
+  def _reduce_656(val, _values, result); end
+
+  def _reduce_657(val, _values, result); end
+
+  def _reduce_658(val, _values, result); end
+
+  def _reduce_659(val, _values, result); end
+
+  def _reduce_66(val, _values, result); end
+
+  def _reduce_660(val, _values, result); end
+
+  def _reduce_661(val, _values, result); end
+
+  def _reduce_662(val, _values, result); end
+
+  def _reduce_663(val, _values, result); end
+
+  def _reduce_664(val, _values, result); end
+
+  def _reduce_665(val, _values, result); end
+
+  def _reduce_666(val, _values, result); end
+
+  def _reduce_667(val, _values, result); end
+
+  def _reduce_669(val, _values, result); end
+
+  def _reduce_67(val, _values, result); end
+
+  def _reduce_670(val, _values, result); end
+
+  def _reduce_671(val, _values, result); end
+
+  def _reduce_672(val, _values, result); end
+
+  def _reduce_673(val, _values, result); end
+
+  def _reduce_674(val, _values, result); end
+
+  def _reduce_675(val, _values, result); end
+
+  def _reduce_676(val, _values, result); end
+
+  def _reduce_677(val, _values, result); end
+
+  def _reduce_678(val, _values, result); end
+
+  def _reduce_679(val, _values, result); end
+
+  def _reduce_68(val, _values, result); end
+
+  def _reduce_680(val, _values, result); end
+
+  def _reduce_681(val, _values, result); end
+
+  def _reduce_682(val, _values, result); end
+
+  def _reduce_683(val, _values, result); end
+
+  def _reduce_686(val, _values, result); end
+
+  def _reduce_687(val, _values, result); end
+
+  def _reduce_688(val, _values, result); end
+
+  def _reduce_689(val, _values, result); end
+
+  def _reduce_690(val, _values, result); end
+
+  def _reduce_691(val, _values, result); end
+
+  def _reduce_692(val, _values, result); end
+
+  def _reduce_693(val, _values, result); end
+
+  def _reduce_694(val, _values, result); end
+
+  def _reduce_697(val, _values, result); end
+
+  def _reduce_698(val, _values, result); end
+
+  def _reduce_7(val, _values, result); end
+
+  def _reduce_701(val, _values, result); end
+
+  def _reduce_702(val, _values, result); end
+
+  def _reduce_703(val, _values, result); end
+
+  def _reduce_704(val, _values, result); end
+
+  def _reduce_706(val, _values, result); end
+
+  def _reduce_707(val, _values, result); end
+
+  def _reduce_709(val, _values, result); end
+
+  def _reduce_710(val, _values, result); end
+
+  def _reduce_711(val, _values, result); end
+
+  def _reduce_712(val, _values, result); end
+
+  def _reduce_713(val, _values, result); end
+
+  def _reduce_714(val, _values, result); end
+
+  def _reduce_715(val, _values, result); end
+
+  def _reduce_72(val, _values, result); end
+
+  def _reduce_728(val, _values, result); end
+
+  def _reduce_729(val, _values, result); end
+
+  def _reduce_73(val, _values, result); end
+
+  def _reduce_734(val, _values, result); end
+
+  def _reduce_735(val, _values, result); end
+
+  def _reduce_736(val, _values, result); end
+
+  def _reduce_74(val, _values, result); end
+
+  def _reduce_740(val, _values, result); end
+
+  def _reduce_744(val, _values, result); end
+
+  def _reduce_76(val, _values, result); end
+
+  def _reduce_77(val, _values, result); end
+
+  def _reduce_78(val, _values, result); end
+
+  def _reduce_79(val, _values, result); end
+
+  def _reduce_80(val, _values, result); end
+
+  def _reduce_81(val, _values, result); end
+
+  def _reduce_82(val, _values, result); end
+
+  def _reduce_83(val, _values, result); end
+
+  def _reduce_84(val, _values, result); end
+
+  def _reduce_85(val, _values, result); end
+
+  def _reduce_86(val, _values, result); end
+
+  def _reduce_87(val, _values, result); end
+
+  def _reduce_88(val, _values, result); end
+
+  def _reduce_89(val, _values, result); end
+
+  def _reduce_9(val, _values, result); end
+
+  def _reduce_90(val, _values, result); end
+
+  def _reduce_92(val, _values, result); end
+
+  def _reduce_93(val, _values, result); end
+
+  def _reduce_94(val, _values, result); end
+
+  def _reduce_95(val, _values, result); end
+
+  def _reduce_96(val, _values, result); end
+
+  def _reduce_97(val, _values, result); end
+
+  def _reduce_98(val, _values, result); end
+
+  def _reduce_99(val, _values, result); end
+
+  def _reduce_none(val, _values, result); end
+
+  def default_encoding(); end
+
+  def endless_method_name(name_t); end
+
+  def local_pop(); end
+
+  def local_push(); end
+
+  def try_declare_numparam(node); end
+
+  def version(); end
+  Racc_arg = ::T.let(nil, ::T.untyped)
+  Racc_debug_parser = ::T.let(nil, ::T.untyped)
+  Racc_token_to_s_table = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Ruby31
+end
+
+module Predicable
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class Proc
+  include ::MethodSource::SourceLocation::ProcExtensions
+  include ::MethodSource::MethodExtensions
+  def <<(arg); end
+
+  def >>(arg); end
+
+  def clone(); end
+end
+
+class Process::Status
+  def self.wait(*arg); end
+end
+
+class Process::Tms
+  def self.keyword_init?(); end
+end
+
+module Process
+  def self._fork(); end
+
+  def self.fork(); end
+end
+
+class Pry::BasicObject
+  include ::ActiveSupport::ForkTracker::CoreExtPrivate
+  include ::ActiveSupport::ForkTracker::CoreExt
+end
+
+module Psych
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::ScalarScanner
+  INTEGER_LEGACY = ::T.let(nil, ::T.untyped)
+  INTEGER_STRICT = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Visitors::RestrictedYAMLTree
+  def visit_Symbol(sym); end
+  DEFAULT_PERMITTED_CLASSES = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Visitors::RestrictedYAMLTree
+end
+
+class Psych::Visitors::Visitor
+  def self.dispatch_cache(); end
+end
+
+module Psych
+  def self.add_builtin_type(type_tag, &block); end
+
+  def self.add_domain_type(domain, type_tag, &block); end
+
+  def self.add_tag(tag, klass); end
+
+  def self.config(); end
+
+  def self.domain_types(*args, **arg, &block); end
+
+  def self.domain_types=(*args, **arg, &block); end
+
+  def self.dump_tags(*args, **arg, &block); end
+
+  def self.dump_tags=(*args, **arg, &block); end
+
+  def self.libyaml_version(); end
+
+  def self.load_tags(*args, **arg, &block); end
+
+  def self.load_tags=(*args, **arg, &block); end
+
+  def self.remove_type(type_tag); end
+
+  def self.safe_dump(o, io=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def self.safe_load_file(filename, **kwargs); end
+
+  def self.unsafe_load(yaml, filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil), freeze: T.unsafe(nil), strict_integer: T.unsafe(nil)); end
+
+  def self.unsafe_load_file(filename, **kwargs); end
+end
+
+class PublicSuffix::Rule::Entry
+  def self.keyword_init?(); end
+end
+
+module PyPI
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class RBI::ASTVisitor
+  extend ::T::Helpers
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
+end
+
+class RBI::Index
+  include ::T::Enumerable
+end
+
+module RBI::Indexable
+  extend ::T::Helpers
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class RBI::Node
+  extend ::T::Helpers
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
+end
+
+class RBI::Visitor
+  extend ::T::Helpers
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
+end
+
+class RDoc::Alias
+  def initialize(text, old_name, new_name, comment, singleton=T.unsafe(nil)); end
+end
+
+class RDoc::AnyMethod
+  def _call_seq(); end
+
+  def section_title(); end
+
+  def section_title=(section_title); end
+end
+
+class RDoc::Attr
+  def initialize(text, name, rw, comment, singleton=T.unsafe(nil)); end
+end
+
+class RDoc::ClassModule
+  def initialize(name, superclass=T.unsafe(nil)); end
+end
+
+class RDoc::CodeObject
+  def initialize_visibility(); end
+end
+
+class RDoc::Comment
+  def initialize(text=T.unsafe(nil), location=T.unsafe(nil), language=T.unsafe(nil)); end
+
+  def line(); end
+
+  def line=(line); end
+end
+
+class RDoc::Constant
+  def initialize(name, value, comment); end
+end
+
+class RDoc::Context
+  def add_module_by_normal_module(mod); end
+
+  def initialize_methods_etc(); end
+
+  def instance_methods(); end
+end
+
+class RDoc::Context::Section
+  def initialize(parent, title, comment); end
+end
+
+class RDoc::CrossReference
+  def initialize(context); end
+
+  def resolve_method(name); end
+end
+
+module RDoc::Encoding
+  HEADER_REGEXP = ::T.let(nil, ::T.untyped)
+end
+
+module RDoc::Encoding
+  def self.detect_encoding(string); end
+
+  def self.remove_magic_comment(string); end
+end
+
+class RDoc::Generator::Darkfish
+  def initialize(store, options); end
+end
+
+class RDoc::Generator::JsonIndex
+  def initialize(parent_generator, options); end
+end
+
+class RDoc::Generator::POT
+  def initialize(store, options); end
+end
+
+class RDoc::Generator::POT::MessageExtractor
+  def initialize(store); end
+end
+
+class RDoc::Generator::POT::POEntry
+  def initialize(msgid, options=T.unsafe(nil)); end
+end
+
+class RDoc::Generator::RI
+  def initialize(store, options); end
+end
+
+class RDoc::I18n::Locale
+  def initialize(name); end
+end
+
+class RDoc::I18n::Text
+  def initialize(raw); end
+end
+
+class RDoc::Markdown
+  def _Table(); end
+
+  def _TableColumn(); end
+
+  def _TableItem(); end
+
+  def _TableLine(); end
+
+  def _TableRow(); end
+
+  def initialize(extensions=T.unsafe(nil), debug=T.unsafe(nil)); end
+end
+
+class RDoc::Markdown::Literals
+  def initialize(str, debug=T.unsafe(nil)); end
+end
+
+class RDoc::Markdown::Literals::MemoEntry
+  def initialize(ans, pos); end
+end
+
+class RDoc::Markdown::Literals::RuleInfo
+  def initialize(name, rendered); end
+end
+
+class RDoc::Markdown::MemoEntry
+  def initialize(ans, pos); end
+end
+
+class RDoc::Markdown::RuleInfo
+  def initialize(name, rendered); end
+end
+
+class RDoc::Markup
+  def add_regexp_handling(pattern, name); end
+
+  def initialize(attribute_manager=T.unsafe(nil)); end
+end
+
+class RDoc::Markup::AttrChanger
+  def self.keyword_init?(); end
+end
+
+class RDoc::Markup::AttrSpan
+  def initialize(length, exclusive); end
+end
+
+class RDoc::Markup::AttributeManager
+  def add_regexp_handling(pattern, name, exclusive=T.unsafe(nil)); end
+
+  def convert_attrs_matching_word_pairs(str, attrs, exclusive); end
+
+  def convert_attrs_word_pair_map(str, attrs, exclusive); end
+
+  def convert_regexp_handlings(str, attrs, exclusive=T.unsafe(nil)); end
+
+  def exclusive?(attr); end
+
+  def exclusive_bitmap(); end
+
+  def regexp_handlings(); end
+  NON_PRINTING_END = ::T.let(nil, ::T.untyped)
+  NON_PRINTING_START = ::T.let(nil, ::T.untyped)
+end
+
+class RDoc::Markup::Attributes
+  def regexp_handling(); end
+end
+
+class RDoc::Markup::Document
+  def initialize(*parts); end
+end
+
+class RDoc::Markup::Formatter
+  def add_regexp_handling_RDOCLINK(); end
+
+  def add_regexp_handling_TIDYLINK(); end
+
+  def convert_regexp_handling(target); end
+
+  def initialize(options, markup=T.unsafe(nil)); end
+end
+
+class RDoc::Markup::Formatter::InlineTag
+  def self.keyword_init?(); end
+end
+
+class RDoc::Markup::Heading
+  def self.keyword_init?(); end
+end
+
+class RDoc::Markup::Include
+  def initialize(file, include_path); end
+end
+
+class RDoc::Markup::IndentedParagraph
+  def initialize(indent, *parts); end
+end
+
+class RDoc::Markup::List
+  def initialize(type=T.unsafe(nil), *items); end
+end
+
+class RDoc::Markup::ListItem
+  def initialize(label=T.unsafe(nil), *parts); end
+end
+
+class RDoc::Markup::Parser::MyStringScanner
+  def [](i); end
+
+  def eos?(); end
+
+  def initialize(input); end
+
+  def matched(); end
+
+  def newline!(); end
+
+  def pos(); end
+
+  def scan(re); end
+
+  def unscan(s); end
+end
+
+class RDoc::Markup::Parser::MyStringScanner
+end
+
+class RDoc::Markup::PreProcess
+  def initialize(input_file_name, include_path); end
+end
+
+class RDoc::Markup::Raw
+  def initialize(*parts); end
+end
+
+class RDoc::Markup::RegexpHandling
+  def ==(o); end
+
+  def initialize(type, text); end
+
+  def text(); end
+
+  def text=(text); end
+
+  def type(); end
+end
+
+class RDoc::Markup::RegexpHandling
+end
+
+class RDoc::Markup::Table
+  def ==(other); end
+
+  def accept(visitor); end
+
+  def align(); end
+
+  def align=(align); end
+
+  def body(); end
+
+  def body=(body); end
+
+  def header(); end
+
+  def header=(header); end
+
+  def initialize(header, align, body); end
+end
+
+class RDoc::Markup::Table
+end
+
+class RDoc::Markup::ToHtml
+  def accept_table(header, body, aligns); end
+
+  def handle_regexp_HARD_BREAK(target); end
+
+  def handle_regexp_HYPERLINK(target); end
+
+  def handle_regexp_RDOCLINK(target); end
+
+  def handle_regexp_TIDYLINK(target); end
+
+  def init_link_notation_regexp_handlings(); end
+
+  def init_regexp_handlings(); end
+end
+
+class RDoc::Markup::ToHtmlCrossref
+  def handle_regexp_CROSSREF(target); end
+
+  def initialize(options, from_path, context, markup=T.unsafe(nil)); end
+end
+
+class RDoc::Markup::ToHtmlSnippet
+  def handle_regexp_CROSSREF(target); end
+
+  def initialize(options, characters=T.unsafe(nil), paragraphs=T.unsafe(nil), markup=T.unsafe(nil)); end
+end
+
+class RDoc::Markup::ToJoinedParagraph
+  def accept_table(*node); end
+
+  def initialize(); end
+end
+
+class RDoc::Markup::ToLabel
+  def handle_regexp_CROSSREF(target); end
+
+  def handle_regexp_HARD_BREAK(*node); end
+
+  def handle_regexp_TIDYLINK(target); end
+
+  def initialize(markup=T.unsafe(nil)); end
+end
+
+class RDoc::Markup::ToMarkdown
+  def handle_regexp_RDOCLINK(target); end
+
+  def handle_regexp_TIDYLINK(target); end
+end
+
+class RDoc::Markup::ToRdoc
+  def accept_table(header, body, aligns); end
+
+  def handle_regexp_HARD_BREAK(target); end
+
+  def handle_regexp_SUPPRESSED_CROSSREF(target); end
+
+  def initialize(markup=T.unsafe(nil)); end
+end
+
+class RDoc::Markup::ToTableOfContents
+  def accept_table(*node); end
+
+  def initialize(); end
+end
+
+class RDoc::Markup::ToTtOnly
+  def initialize(markup=T.unsafe(nil)); end
+end
+
+class RDoc::MethodAttr
+  def initialize(text, name); end
+end
+
+class RDoc::Mixin
+  def initialize(name, comment); end
+end
+
+class RDoc::Options
+  def initialize(loaded_options=T.unsafe(nil)); end
+
+  def override(map); end
+end
+
+class RDoc::Options
+  def self.load_options(); end
+end
+
+class RDoc::Parser
+  def initialize(top_level, file_name, content, options, stats); end
+end
+
+class RDoc::Parser::C
+  def add_alias(var_name, class_obj, old_name, new_name, comment); end
+
+  def do_classes_and_modules(); end
+
+  def new_comment(text=T.unsafe(nil), location=T.unsafe(nil), language=T.unsafe(nil)); end
+end
+
+class RDoc::Parser::ChangeLog
+  def parse_date(date); end
+end
+
+module RDoc::Parser::ChangeLog::Git
+  def create_entries(entries); end
+
+  def parse_entries(); end
+
+  def parse_info(info); end
+  HEADING_LEVEL = ::T.let(nil, ::T.untyped)
+end
+
+class RDoc::Parser::ChangeLog::Git::LogEntry
+  def accept(visitor); end
+
+  def aref(); end
+
+  def author(); end
+
+  def author=(_); end
+
+  def base(); end
+
+  def base=(_); end
+
+  def commit(); end
+
+  def commit=(_); end
+
+  def contents(); end
+
+  def contents=(_); end
+
+  def date(); end
+
+  def date=(_); end
+
+  def email(); end
+
+  def email=(_); end
+
+  def initialize(base, commit, author, email, date, contents); end
+
+  def label(context=T.unsafe(nil)); end
+
+  def level(); end
+
+  def text(); end
+end
+
+class RDoc::Parser::ChangeLog::Git::LogEntry
+  def self.[](*arg); end
+
+  def self.keyword_init?(); end
+
+  def self.members(); end
+end
+
+module RDoc::Parser::ChangeLog::Git
+end
+
+class RDoc::Parser::RipperStateLex
+  def get_squashed_tk(); end
+
+  def initialize(code); end
+  EXPR_ARG = ::T.let(nil, ::T.untyped)
+  EXPR_ARG_ANY = ::T.let(nil, ::T.untyped)
+  EXPR_BEG = ::T.let(nil, ::T.untyped)
+  EXPR_BEG_ANY = ::T.let(nil, ::T.untyped)
+  EXPR_CLASS = ::T.let(nil, ::T.untyped)
+  EXPR_CMDARG = ::T.let(nil, ::T.untyped)
+  EXPR_DOT = ::T.let(nil, ::T.untyped)
+  EXPR_END = ::T.let(nil, ::T.untyped)
+  EXPR_ENDARG = ::T.let(nil, ::T.untyped)
+  EXPR_ENDFN = ::T.let(nil, ::T.untyped)
+  EXPR_END_ANY = ::T.let(nil, ::T.untyped)
+  EXPR_FITEM = ::T.let(nil, ::T.untyped)
+  EXPR_FNAME = ::T.let(nil, ::T.untyped)
+  EXPR_LABEL = ::T.let(nil, ::T.untyped)
+  EXPR_LABELED = ::T.let(nil, ::T.untyped)
+  EXPR_MID = ::T.let(nil, ::T.untyped)
+  EXPR_NONE = ::T.let(nil, ::T.untyped)
+  EXPR_VALUE = ::T.let(nil, ::T.untyped)
+  RIPPER_HAS_LEX_STATE = ::T.let(nil, ::T.untyped)
+end
+
+class RDoc::Parser::RipperStateLex::InnerStateLex
+  def initialize(code); end
+
+  def on_default(event, tok, data); end
+end
+
+class RDoc::Parser::RipperStateLex::InnerStateLex
+end
+
+class RDoc::Parser::RipperStateLex::Token
+  def char_no(); end
+
+  def char_no=(_); end
+
+  def kind(); end
+
+  def kind=(_); end
+
+  def line_no(); end
+
+  def line_no=(_); end
+
+  def state(); end
+
+  def state=(_); end
+
+  def text(); end
+
+  def text=(_); end
+end
+
+class RDoc::Parser::RipperStateLex::Token
+  def self.[](*arg); end
+
+  def self.keyword_init?(); end
+
+  def self.members(); end
+end
+
+class RDoc::Parser::RipperStateLex
+  def self.end?(token); end
+
+  def self.parse(code); end
+end
+
+class RDoc::Parser::Ruby
+  def get_included_module_with_optional_parens(); end
+
+  def parse_included_with_activesupport_concern(container, comment); end
+
+  def retrieve_comment_body(tk); end
+end
+
+module RDoc::Parser::RubyTools
+  def skip_tkspace_without_nl(); end
+end
+
+class RDoc::RD::BlockParser
+  Racc_debug_parser = ::T.let(nil, ::T.untyped)
+end
+
+class RDoc::RD::Inline
+  def initialize(rdoc, reference); end
+end
+
+class RDoc::RD::InlineParser
+  def initialize(block_parser); end
+  Racc_debug_parser = ::T.let(nil, ::T.untyped)
+end
+
+class RDoc::RI::Driver
+  def initialize(initial_options=T.unsafe(nil)); end
+end
+
+class RDoc::RI::Driver::NotFoundError
+  def initialize(klass, suggestions=T.unsafe(nil)); end
+end
+
+RDoc::RI::Store = RDoc::Store
+
+class RDoc::Require
+  def initialize(name, comment); end
+end
+
+class RDoc::Stats
+  def initialize(store, num_files, verbosity=T.unsafe(nil)); end
+end
+
+class RDoc::Stats::Quiet
+  def initialize(num_files); end
+end
+
+class RDoc::Store
+  def initialize(path=T.unsafe(nil), type=T.unsafe(nil)); end
+
+  def unmatched_constant_alias(); end
+
+  def update_parser_of_file(absolute_name, parser); end
+end
+
+class RDoc::Store::MissingFileError
+  def initialize(store, file, name); end
+end
+
+module RDoc::Text
+  def language(); end
+
+  def language=(language); end
+end
+
+class RDoc::TopLevel
+  def initialize(absolute_name, relative_name=T.unsafe(nil)); end
+end
+
+module RDoc
+  def self.home(); end
+end
+
+class REXML::XPathParser
+  DEBUG = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Example::Procsy
+  def ==(*a, &b); end
+
+  def eql?(*a, &b); end
+
+  def ruby2_keywords(*a, &b); end
+end
+
+class RSpec::Core::ExampleGroup
+  include ::RSpec::Core::MockingAdapters::RSpec
+  include ::RSpec::Mocks::ExampleMethods
+  include ::RSpec::Mocks::ArgumentMatchers
+  include ::RSpec::Mocks::ExampleMethods::ExpectHost
+  include ::RSpec::Matchers
+end
+
+class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage
+  def self.keyword_init?(); end
+end
+
+class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage
+  def self.keyword_init?(); end
+end
+
+module RSpec::Core::HashImitatable
+  def assert_valid_keys(*args, &block); end
+
+  def compact_blank(*args, &block); end
+
+  def compact_blank!(*args, &block); end
+
+  def deconstruct_keys(*args, &block); end
+
+  def deep_stringify_keys(*args, &block); end
+
+  def deep_stringify_keys!(*args, &block); end
+
+  def deep_symbolize_keys(*args, &block); end
+
+  def deep_symbolize_keys!(*args, &block); end
+
+  def deep_transform_keys(*args, &block); end
+
+  def deep_transform_keys!(*args, &block); end
+
+  def exclude?(*args, &block); end
+
+  def excluding(*args, &block); end
+
+  def extractable_options?(*args, &block); end
+
+  def filter_map(*args, &block); end
+
+  def including(*args, &block); end
+
+  def index_by(*args, &block); end
+
+  def index_with(*args, &block); end
+
+  def many?(*args, &block); end
+
+  def pick(*args, &block); end
+
+  def pluck(*args, &block); end
+
+  def stringify_keys(*args, &block); end
+
+  def stringify_keys!(*args, &block); end
+
+  def symbolize_keys(*args, &block); end
+
+  def symbolize_keys!(*args, &block); end
+
+  def tally(*args, &block); end
+
+  def to_options(*args, &block); end
+
+  def to_options!(*args, &block); end
+
+  def without(*args, &block); end
+end
+
+class RSpec::Core::Hooks::Hook
+  def self.keyword_init?(); end
+end
+
+class RSpec::Core::Invocations::PrintHelp
+  def self.keyword_init?(); end
+end
+
+module RSpec::Core::MockingAdapters
+end
+
+module RSpec::Core::MockingAdapters::RSpec
+  include ::RSpec::Mocks::ExampleMethods
+  include ::RSpec::Mocks::ArgumentMatchers
+  include ::RSpec::Mocks::ExampleMethods::ExpectHost
+  def setup_mocks_for_rspec(); end
+
+  def teardown_mocks_for_rspec(); end
+
+  def verify_mocks_for_rspec(); end
+end
+
+module RSpec::Core::MockingAdapters::RSpec
+  def self.configuration(); end
+
+  def self.framework_name(); end
+end
+
+module RSpec::Core::MockingAdapters
+end
+
+class RSpec::Core::Notifications::DeprecationNotification
+  def self.keyword_init?(); end
+end
+
+class RSpec::Core::Notifications::ExampleNotification
+  def self.keyword_init?(); end
+end
+
+class RSpec::Core::Notifications::GroupNotification
+  def self.keyword_init?(); end
+end
+
+class RSpec::Core::Notifications::MessageNotification
+  def self.keyword_init?(); end
+end
+
+class RSpec::Core::Notifications::SeedNotification
+  def self.keyword_init?(); end
+end
+
+class RSpec::Core::Notifications::StartNotification
+  def self.keyword_init?(); end
+end
+
+class RSpec::Core::Notifications::SummaryNotification
+  def self.keyword_init?(); end
+end
+
+class RSpec::Core::OutputWrapper
+  def as_json(*args, &block); end
+
+  def check_winsize_changed(*args, &block); end
+
+  def clear_screen(*args, &block); end
+
+  def console_mode(*args, &block); end
+
+  def console_mode=(*args, &block); end
+
+  def cursor_down(*args, &block); end
+
+  def cursor_left(*args, &block); end
+
+  def cursor_right(*args, &block); end
+
+  def cursor_up(*args, &block); end
+
+  def erase_line(*args, &block); end
+
+  def erase_screen(*args, &block); end
+
+  def goto_column(*args, &block); end
+
+  def readline_nonblock(*args, &block); end
+
+  def scroll_backward(*args, &block); end
+
+  def scroll_forward(*args, &block); end
+
+  def set_encoding_by_bom(*args, &block); end
+
+  def wait_priority(*args, &block); end
+end
+
+class RSpec::Core::SharedContext::Recording
+  def self.keyword_init?(); end
+end
+
+class RSpec::Expectations::BlockSnippetExtractor::BlockLocator
+  def self.keyword_init?(); end
+end
+
+class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor
+  def self.keyword_init?(); end
+end
+
+class RSpec::Expectations::MultipleExpectationsNotMetError
+  include ::RSpec::Core::MultipleExceptionError::InterfaceTag
+end
+
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution
+  def self.keyword_init?(); end
+end
+
+class RSpec::Mocks::ClassNewMethodReference
+  CLASS_NEW = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::Proxy::SpecificMessage
+  def self.keyword_init?(); end
+end
+
+module RSpec::Sorbet::Doubles
+  extend ::T::Helpers
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class RSpec::Support::ObjectFormatter::BaseInspector
+  def self.keyword_init?(); end
+end
+
+class RSpec::Support::ObjectFormatter::InspectableItem
+  def self.keyword_init?(); end
+end
+
+module Racc
+  Racc_No_Extensions = ::T.let(nil, ::T.untyped)
+end
+
+class Racc::CparseParams
+end
+
+class Racc::CparseParams
+end
+
+class Racc::StateTransitionTable
+  def self.keyword_init?(); end
+end
+
+class Rack::Headers
+  def except(*a); end
+end
+
+class Rack::Multipart::Parser::MultipartInfo
+  def self.keyword_init?(); end
+end
+
+class Ractor::ClosedError
+end
+
+class Ractor::ClosedError
+end
+
+class Ractor::Error
+end
+
+class Ractor::Error
+end
+
+class Ractor::IsolationError
+end
+
+class Ractor::IsolationError
+end
+
+class Ractor::MovedError
+end
+
+class Ractor::MovedError
+end
+
+class Ractor::MovedObject
+  def !(*arg); end
+
+  def !=(*arg); end
+
+  def ==(*arg); end
+
+  def __id__(*arg); end
+
+  def equal?(*arg); end
+end
+
+class Ractor::MovedObject
+end
+
+class Ractor::RemoteError
+  def ractor(); end
+end
+
+class Ractor::RemoteError
+end
+
+class Ractor::UnsafeError
+end
+
+class Ractor::UnsafeError
+end
+
+class Ractor
+  def self.new(*args, name: T.unsafe(nil), &block); end
+end
+
+class Random::Base
+  include ::Random::Formatter
+  def bytes(arg); end
+
+  def initialize(*arg); end
+
+  def seed(); end
+end
+
+class Random::Base
+  extend ::Random::Formatter
+end
+
+class Random
+  def self.bytes(arg); end
+
+  def self.seed(); end
+end
+
+class Range
+  def %(arg); end
+
+  def entries(); end
+
+  def to_a(); end
+end
+
+module RbConfig
+  def self.expand(val, config=T.unsafe(nil)); end
+
+  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
+
+  def self.ruby(); end
+end
+
+class Refinement
+end
+
+class Refinement
+end
+
+class Regexp::Token
+  def self.keyword_init?(); end
+end
+
+module Reline
+  DEFAULT_DIALOG_CONTEXT = ::T.let(nil, ::T.untyped)
+  DEFAULT_DIALOG_PROC_AUTOCOMPLETE = ::T.let(nil, ::T.untyped)
+  FILENAME_COMPLETION_PROC = ::T.let(nil, ::T.untyped)
+  HISTORY = ::T.let(nil, ::T.untyped)
+  USERNAME_COMPLETION_PROC = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Reline::ANSI
+  CAPNAME_KEY_BINDINGS = ::T.let(nil, ::T.untyped)
+  END_BRACKETED_PASTE = ::T.let(nil, ::T.untyped)
+  START_BRACKETED_PASTE = ::T.let(nil, ::T.untyped)
+end
+
+class Reline::Config
+  KEYSEQ_PATTERN = ::T.let(nil, ::T.untyped)
+  VARIABLE_NAMES = ::T.let(nil, ::T.untyped)
+  VARIABLE_NAME_SYMBOLS = ::T.let(nil, ::T.untyped)
+end
+
+class Reline::Core
+  ATTR_READER_NAMES = ::T.let(nil, ::T.untyped)
+end
+
+Reline::IOGate = Reline::ANSI
+
+Reline::Key = Struct::Key
+
+class Reline::KeyActor::Base
+  MAPPING = ::T.let(nil, ::T.untyped)
+end
+
+class Reline::KeyActor::Emacs
+  MAPPING = ::T.let(nil, ::T.untyped)
+end
+
+class Reline::KeyActor::ViCommand
+  MAPPING = ::T.let(nil, ::T.untyped)
+end
+
+class Reline::KeyActor::ViInsert
+  MAPPING = ::T.let(nil, ::T.untyped)
+end
+
+module Reline::KillRing::State
+  CONTINUED = ::T.let(nil, ::T.untyped)
+  FRESH = ::T.let(nil, ::T.untyped)
+  PROCESSED = ::T.let(nil, ::T.untyped)
+  YANK = ::T.let(nil, ::T.untyped)
+end
+
+class Reline::LineEditor
+  DIALOG_DEFAULT_HEIGHT = ::T.let(nil, ::T.untyped)
+  PROMPT_LIST_CACHE_TIMEOUT = ::T.let(nil, ::T.untyped)
+  VI_MOTIONS = ::T.let(nil, ::T.untyped)
+end
+
+Reline::LineEditor::CompletionJourneyData = Struct::CompletionJourneyData
+
+module Reline::LineEditor::CompletionState
+  COMPLETION = ::T.let(nil, ::T.untyped)
+  JOURNEY = ::T.let(nil, ::T.untyped)
+  MENU = ::T.let(nil, ::T.untyped)
+  MENU_WITH_PERFECT_MATCH = ::T.let(nil, ::T.untyped)
+  NORMAL = ::T.let(nil, ::T.untyped)
+  PERFECT_MATCH = ::T.let(nil, ::T.untyped)
+end
+
+Reline::LineEditor::MenuInfo = Struct::MenuInfo
+
+module Reline::Terminfo
+  extend ::Fiddle
+  extend ::Fiddle::CParser
+end
+
+class Reline::Unicode
+  CSI_REGEXP = ::T.let(nil, ::T.untyped)
+  CSI_REGEXP_INDEX = ::T.let(nil, ::T.untyped)
+  EscapedChars = ::T.let(nil, ::T.untyped)
+  EscapedPairs = ::T.let(nil, ::T.untyped)
+  GRAPHEME_CLUSTER_INDEX = ::T.let(nil, ::T.untyped)
+  HalfwidthDakutenHandakuten = ::T.let(nil, ::T.untyped)
+  MBCharWidthRE = ::T.let(nil, ::T.untyped)
+  NON_PRINTING_END = ::T.let(nil, ::T.untyped)
+  NON_PRINTING_END_INDEX = ::T.let(nil, ::T.untyped)
+  NON_PRINTING_START = ::T.let(nil, ::T.untyped)
+  NON_PRINTING_START_INDEX = ::T.let(nil, ::T.untyped)
+  OSC_REGEXP = ::T.let(nil, ::T.untyped)
+  OSC_REGEXP_INDEX = ::T.let(nil, ::T.untyped)
+  WIDTH_SCANNER = ::T.let(nil, ::T.untyped)
+end
+
+class Reline::Unicode::EastAsianWidth
+  TYPE_A = ::T.let(nil, ::T.untyped)
+  TYPE_F = ::T.let(nil, ::T.untyped)
+  TYPE_H = ::T.let(nil, ::T.untyped)
+  TYPE_N = ::T.let(nil, ::T.untyped)
+  TYPE_NA = ::T.let(nil, ::T.untyped)
+  TYPE_W = ::T.let(nil, ::T.untyped)
+end
+
+class Requirements
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
+class Requirements
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class Resolv::DNS
+  def extract_resources(msg, name, typeclass); end
+  RequestID = ::T.let(nil, ::T.untyped)
+  RequestIDMutex = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Config
+  def initialize(config_info=T.unsafe(nil)); end
+end
+
+class Resolv::DNS::Label::Str
+  def initialize(string); end
+end
+
+class Resolv::DNS::Message
+  def initialize(id=T.unsafe(nil)); end
+end
+
+class Resolv::DNS::Message::MessageDecoder
+  def initialize(data); end
+end
+
+class Resolv::DNS::Requester::ConnectedUDP
+  def initialize(host, port=T.unsafe(nil)); end
+
+  def lazy_initialize(); end
+end
+
+class Resolv::DNS::Requester::Sender
+  def initialize(msg, data, sock); end
+end
+
+class Resolv::DNS::Requester::TCP
+  def initialize(host, port=T.unsafe(nil)); end
+end
+
+class Resolv::DNS::Requester::UnconnectedUDP
+  def initialize(*nameserver_port); end
+
+  def lazy_initialize(); end
+end
+
+class Resolv::DNS::Requester::UnconnectedUDP::Sender
+  def initialize(msg, data, sock, host, port); end
+end
+
+class Resolv::DNS::Resource
+  ClassValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::LOC
+  def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude); end
+end
+
+class Resolv::DNS
+  def self.allocate_request_id(host, port); end
+
+  def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end
+
+  def self.free_request_id(host, port, id); end
+
+  def self.random(arg); end
+end
+
+class Resolv::IPv6
+  Regex_8HexLinkLocal = ::T.let(nil, ::T.untyped)
+  Regex_CompressedHexLinkLocal = ::T.let(nil, ::T.untyped)
+end
+
+class Resource
+  include ::FileUtils::StreamUtils_
+  def on_arch_conditional(arm: T.unsafe(nil), intel: T.unsafe(nil)); end
+
+  def on_arm(&block); end
+
+  def on_big_sur(or_condition=T.unsafe(nil), &block); end
+
+  def on_catalina(or_condition=T.unsafe(nil), &block); end
+
+  def on_el_capitan(or_condition=T.unsafe(nil), &block); end
+
+  def on_high_sierra(or_condition=T.unsafe(nil), &block); end
+
+  def on_intel(&block); end
+
+  def on_linux(&block); end
+
+  def on_macos(&block); end
+
+  def on_mojave(or_condition=T.unsafe(nil), &block); end
+
+  def on_monterey(or_condition=T.unsafe(nil), &block); end
+
+  def on_sierra(or_condition=T.unsafe(nil), &block); end
+
+  def on_sonoma(or_condition=T.unsafe(nil), &block); end
+
+  def on_system(linux, macos:, &block); end
+
+  def on_system_conditional(macos: T.unsafe(nil), linux: T.unsafe(nil)); end
+
+  def on_ventura(or_condition=T.unsafe(nil), &block); end
+end
+
+class Resource::Partial
+  def self.[](*arg); end
+
+  def self.keyword_init?(); end
+
+  def self.members(); end
+end
+
+class Ripper
+  def column(); end
+
+  def debug_output(); end
+
+  def debug_output=(debug_output); end
+
+  def encoding(); end
+
+  def end_seen?(); end
+
+  def error?(); end
+
+  def filename(); end
+
+  def initialize(*arg); end
+
+  def lineno(); end
+
+  def parse(); end
+
+  def state(); end
+
+  def token(); end
+
+  def yydebug(); end
+
+  def yydebug=(yydebug); end
+  EXPR_ARG = ::T.let(nil, ::T.untyped)
+  EXPR_ARG_ANY = ::T.let(nil, ::T.untyped)
+  EXPR_BEG = ::T.let(nil, ::T.untyped)
+  EXPR_BEG_ANY = ::T.let(nil, ::T.untyped)
+  EXPR_CLASS = ::T.let(nil, ::T.untyped)
+  EXPR_CMDARG = ::T.let(nil, ::T.untyped)
+  EXPR_DOT = ::T.let(nil, ::T.untyped)
+  EXPR_END = ::T.let(nil, ::T.untyped)
+  EXPR_ENDARG = ::T.let(nil, ::T.untyped)
+  EXPR_ENDFN = ::T.let(nil, ::T.untyped)
+  EXPR_END_ANY = ::T.let(nil, ::T.untyped)
+  EXPR_FITEM = ::T.let(nil, ::T.untyped)
+  EXPR_FNAME = ::T.let(nil, ::T.untyped)
+  EXPR_LABEL = ::T.let(nil, ::T.untyped)
+  EXPR_LABELED = ::T.let(nil, ::T.untyped)
+  EXPR_MID = ::T.let(nil, ::T.untyped)
+  EXPR_NONE = ::T.let(nil, ::T.untyped)
+  EXPR_VALUE = ::T.let(nil, ::T.untyped)
+  PARSER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
+  SCANNER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
+  Version = ::T.let(nil, ::T.untyped)
 end
 
-class RuboCop::Cask::AST::Stanza
-  def app?(); end
+class Ripper::Filter
+  def initialize(src, filename=T.unsafe(nil), lineno=T.unsafe(nil)); end
+end
 
-  def appcast?(); end
+class Ripper::Lexer
+  def errors(); end
 
-  def arch?(); end
+  def lex(**kw); end
 
-  def artifact?(); end
+  def parse(raise_errors: T.unsafe(nil)); end
 
-  def audio_unit_plugin?(); end
+  def scan(**kw); end
 
-  def auto_updates?(); end
+  def tokenize(**kw); end
+end
 
-  def binary?(); end
+class Ripper::Lexer::Elem
+  def [](index); end
 
-  def caveats?(); end
+  def event(); end
 
-  def colorpicker?(); end
+  def event=(event); end
 
-  def conflicts_with?(); end
+  def initialize(pos, event, tok, state, message=T.unsafe(nil)); end
 
-  def container?(); end
+  def message(); end
 
-  def depends_on?(); end
+  def message=(message); end
 
-  def desc?(); end
+  def pos(); end
 
-  def dictionary?(); end
+  def pos=(pos); end
 
-  def font?(); end
+  def state(); end
 
-  def homepage?(); end
+  def state=(state); end
 
-  def input_method?(); end
+  def to_a(); end
 
-  def installer?(); end
+  def tok(); end
 
-  def internet_plugin?(); end
+  def tok=(tok); end
+end
 
-  def keyboard_layout?(); end
+class Ripper::Lexer::Elem
+end
 
-  def language?(); end
+class Ripper::Lexer::State
+  def &(i); end
 
-  def livecheck?(); end
+  def ==(i); end
 
-  def manpage?(); end
+  def [](index); end
 
-  def mdimporter?(); end
+  def allbits?(i); end
 
-  def name?(); end
+  def anybits?(i); end
 
-  def on_arch_conditional?(); end
+  def initialize(i); end
 
-  def on_arm?(); end
+  def nobits?(i); end
 
-  def on_big_sur?(); end
+  def to_i(); end
 
-  def on_catalina?(); end
+  def to_int(); end
 
-  def on_el_capitan?(); end
+  def |(i); end
+end
 
-  def on_high_sierra?(); end
+class Ripper::Lexer::State
+end
 
-  def on_intel?(); end
+class Ripper::Lexer
+end
 
-  def on_mojave?(); end
+class Ripper::SexpBuilder
+  def on_BEGIN(*args); end
 
-  def on_monterey?(); end
+  def on_CHAR(tok); end
 
-  def on_sierra?(); end
+  def on_END(*args); end
 
-  def on_sonoma?(); end
+  def on___end__(tok); end
 
-  def on_ventura?(); end
+  def on_alias(*args); end
 
-  def pkg?(); end
+  def on_alias_error(*args); end
 
-  def postflight?(); end
+  def on_aref(*args); end
 
-  def preflight?(); end
+  def on_aref_field(*args); end
 
-  def prefpane?(); end
+  def on_arg_ambiguous(*args); end
 
-  def qlplugin?(); end
+  def on_arg_paren(*args); end
 
-  def screen_saver?(); end
+  def on_args_add(*args); end
 
-  def service?(); end
+  def on_args_add_block(*args); end
 
-  def sha256?(); end
+  def on_args_add_star(*args); end
 
-  def stage_only?(); end
+  def on_args_forward(*args); end
 
-  def suite?(); end
+  def on_args_new(*args); end
 
-  def uninstall?(); end
+  def on_array(*args); end
 
-  def uninstall_postflight?(); end
+  def on_aryptn(*args); end
 
-  def uninstall_preflight?(); end
+  def on_assign(*args); end
 
-  def url?(); end
+  def on_assign_error(*args); end
 
-  def version?(); end
+  def on_assoc_new(*args); end
 
-  def vst3_plugin?(); end
+  def on_assoc_splat(*args); end
 
-  def vst_plugin?(); end
+  def on_assoclist_from_args(*args); end
 
-  def zap?(); end
-end
+  def on_backref(tok); end
 
-module RuboCop::Cop::Cask::CaskHelp
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_backtick(tok); end
 
-module RuboCop::Cop::Cask::CaskHelp
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
+  def on_bare_assoc_hash(*args); end
 
-class RuboCop::Cop::Cask::Desc
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_begin(*args); end
 
-class RuboCop::Cop::Cask::HomepageUrlTrailingSlash
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_binary(*args); end
 
-class RuboCop::Cop::Cask::NoOverrides
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_block_var(*args); end
 
-module RuboCop::Cop::Cask::OnDescStanza
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_blockarg(*args); end
 
-module RuboCop::Cop::Cask::OnHomepageStanza
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_bodystmt(*args); end
 
-class RuboCop::Cop::Cask::OnSystemConditionals
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_brace_block(*args); end
 
-module RuboCop::Cop::Cask::OnUrlStanza
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_break(*args); end
 
-class RuboCop::Cop::Cask::StanzaGrouping
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_call(*args); end
 
-class RuboCop::Cop::Cask::StanzaOrder
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_case(*args); end
 
-class RuboCop::Cop::Cask::Url
-  include ::RuboCop::Cop::CommentsHelp
-end
+  def on_class(*args); end
 
-class RuboCop::Cop::Cask::Variables
-  include ::RuboCop::Cop::CommentsHelp
-  def variable_assignment(param0); end
-end
+  def on_class_name_error(*args); end
 
-class RuboCop::Cop::Cop
-  def highlights(); end
+  def on_comma(tok); end
 
-  def messages(); end
-end
+  def on_command(*args); end
 
-class RuboCop::Cop::FormulaAudit::ComponentsOrder
-  def depends_on_node?(param0=T.unsafe(nil)); end
-end
+  def on_command_call(*args); end
 
-class RuboCop::Cop::FormulaAudit::DependencyOrder
-  def build_with_dependency_node(param0); end
+  def on_comment(tok); end
 
-  def buildtime_dependency?(param0); end
+  def on_const(tok); end
 
-  def dependency_name_node(param0); end
+  def on_const_path_field(*args); end
 
-  def depends_on_node?(param0=T.unsafe(nil)); end
+  def on_const_path_ref(*args); end
 
-  def negate_normal_dependency?(param0); end
+  def on_const_ref(*args); end
 
-  def optional_dependency?(param0); end
+  def on_cvar(tok); end
 
-  def recommended_dependency?(param0); end
+  def on_def(*args); end
 
-  def test_dependency?(param0); end
+  def on_defined(*args); end
 
-  def uses_from_macos_node?(param0=T.unsafe(nil)); end
-end
+  def on_defs(*args); end
 
-class RuboCop::Cop::FormulaAudit::DeprecateDisableDate
-  def date(param0); end
-end
+  def on_do_block(*args); end
 
-class RuboCop::Cop::FormulaAudit::DeprecateDisableReason
-  def reason(param0); end
-end
+  def on_dot2(*args); end
 
-class RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL
-  def correctable_shell_completion_node(param0); end
+  def on_dot3(*args); end
 
-  def shell_completion_node(param0); end
-end
+  def on_dyna_symbol(*args); end
 
-class RuboCop::Cop::FormulaAudit::GitUrls
-  def url_has_revision?(param0=T.unsafe(nil)); end
-end
+  def on_else(*args); end
 
-class RuboCop::Cop::FormulaAudit::Licenses
-  def license_exception?(param0=T.unsafe(nil)); end
-end
+  def on_elsif(*args); end
 
-class RuboCop::Cop::FormulaAudit::Miscellaneous
-  def conditional_dependencies(param0); end
+  def on_embdoc(tok); end
 
-  def destructure_hash(param0=T.unsafe(nil)); end
+  def on_embdoc_beg(tok); end
 
-  def formula_path_strings(param0, param1); end
+  def on_embdoc_end(tok); end
 
-  def hash_dep(param0=T.unsafe(nil)); end
+  def on_embexpr_beg(tok); end
 
-  def languageNodeModule?(param0); end
-end
+  def on_embexpr_end(tok); end
 
-class RuboCop::Cop::FormulaAudit::OptionDeclarations
-  def depends_on_build_with(param0); end
-end
+  def on_embvar(tok); end
 
-class RuboCop::Cop::FormulaAudit::Patches
-  def patch_data?(param0); end
-end
+  def on_ensure(*args); end
 
-class RuboCop::Cop::FormulaAudit::Test
-  def test_calls(param0); end
-end
+  def on_excessed_comma(*args); end
 
-class RuboCop::Cop::FormulaAudit::Text
-  def prefix_path(param0); end
-end
+  def on_fcall(*args); end
 
-class RuboCop::Cop::FormulaAuditStrict::GitUrls
-  def url_has_tag?(param0=T.unsafe(nil)); end
-end
+  def on_field(*args); end
 
-class RuboCop::Cop::FormulaAuditStrict::Text
-  def interpolated_share_path_starts_with(param0, param1); end
+  def on_float(tok); end
 
-  def share_path_starts_with(param0, param1); end
-end
+  def on_fndptn(*args); end
 
-class RuboCop::Cop::FormulaCop
-  def dependency_name_hash_match?(param0, param1); end
+  def on_for(*args); end
 
-  def dependency_type_hash_match?(param0, param1); end
+  def on_gvar(tok); end
 
-  def initialize(*args, &blk); end
+  def on_hash(*args); end
 
-  def required_dependency?(param0); end
+  def on_heredoc_beg(tok); end
 
-  def required_dependency_name?(param0, param1); end
-end
+  def on_heredoc_end(tok); end
 
-class RuboCop::Cop::FormulaCop
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-end
+  def on_hshptn(*args); end
 
-module RuboCop::Cop::HelperFunctions
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
+  def on_ident(tok); end
 
-class RuboCop::Cop::Homebrew::MoveToExtendOS
-  def os_check?(param0=T.unsafe(nil)); end
-end
+  def on_if(*args); end
 
-module RuboCop::Cop::OnSystemConditionalsHelper
-  def hardware_cpu_search(param0, method:); end
+  def on_if_mod(*args); end
 
-  def if_arch_node_search(param0, arch:); end
+  def on_ifop(*args); end
 
-  def if_base_os_node_search(param0, base_os:); end
+  def on_ignored_nl(tok); end
 
-  def if_macos_version_node_search(param0, os_version:); end
+  def on_ignored_sp(tok); end
 
-  def macos_version_comparison_search(param0, os_version:); end
+  def on_imaginary(tok); end
 
-  def on_macos_version_method_call(param0=T.unsafe(nil), on_method:); end
+  def on_in(*args); end
 
-  def on_system_method_call(param0=T.unsafe(nil)); end
-end
+  def on_int(tok); end
 
-module RuboCop::RSpec::ExpectOffense
-  def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end
+  def on_ivar(tok); end
 
-  def expect_no_corrections(); end
+  def on_kw(tok); end
 
-  def expect_no_offenses(source, file=T.unsafe(nil)); end
+  def on_kwrest_param(*args); end
 
-  def expect_offense(source, file=T.unsafe(nil), severity: T.unsafe(nil), chomp: T.unsafe(nil), **replacements); end
+  def on_label(tok); end
 
-  def format_offense(source, **replacements); end
+  def on_label_end(tok); end
 
-  def parse_annotations(source, raise_error: T.unsafe(nil), **replacements); end
+  def on_lambda(*args); end
 
-  def parse_processed_source(source, file=T.unsafe(nil)); end
+  def on_lbrace(tok); end
 
-  def set_formatter_options(); end
-end
+  def on_lbracket(tok); end
 
-class RuboCop::RSpec::ExpectOffense::AnnotatedSource
-  def ==(other); end
+  def on_lparen(tok); end
 
-  def annotations(); end
+  def on_magic_comment(*args); end
 
-  def initialize(lines, annotations); end
+  def on_massign(*args); end
 
-  def lines(); end
+  def on_method_add_arg(*args); end
 
-  def match_annotations?(other); end
+  def on_method_add_block(*args); end
 
-  def plain_source(); end
+  def on_mlhs_add(*args); end
 
-  def with_offense_annotations(offenses); end
-  ABBREV = ::T.let(nil, ::T.untyped)
-  ANNOTATION_PATTERN = ::T.let(nil, ::T.untyped)
-end
+  def on_mlhs_add_post(*args); end
 
-class RuboCop::RSpec::ExpectOffense::AnnotatedSource
-  def self.parse(annotated_source); end
-end
+  def on_mlhs_add_star(*args); end
 
-module RuboCop::RSpec::ExpectOffense
-end
+  def on_mlhs_new(*args); end
 
-class RuboCop::RSpec::ParallelFormatter
-  def dump_pending(*arg); end
-end
+  def on_mlhs_paren(*args); end
 
-class RuboCop::RSpec::ParallelFormatter
-end
+  def on_module(*args); end
 
-class RubyLex
-  include ::RubyToken
-  def Fail(err=T.unsafe(nil), *rest); end
+  def on_mrhs_add(*args); end
 
-  def Raise(err=T.unsafe(nil), *rest); end
+  def on_mrhs_add_star(*args); end
 
-  def char_no(); end
+  def on_mrhs_new(*args); end
 
-  def each_top_level_statement(); end
+  def on_mrhs_new_from_args(*args); end
 
-  def eof?(); end
+  def on_next(*args); end
 
-  def exception_on_syntax_error(); end
+  def on_nl(tok); end
 
-  def exception_on_syntax_error=(exception_on_syntax_error); end
+  def on_nokw_param(*args); end
 
-  def get_readed(); end
+  def on_op(tok); end
 
-  def getc(); end
+  def on_opassign(*args); end
 
-  def getc_of_rests(); end
+  def on_operator_ambiguous(*args); end
 
-  def gets(); end
+  def on_param_error(*args); end
 
-  def identify_comment(); end
+  def on_params(*args); end
 
-  def identify_gvar(); end
+  def on_paren(*args); end
 
-  def identify_here_document(); end
+  def on_period(tok); end
 
-  def identify_identifier(); end
+  def on_program(*args); end
 
-  def identify_number(); end
+  def on_qsymbols_add(*args); end
 
-  def identify_quotation(); end
+  def on_qsymbols_beg(tok); end
 
-  def identify_string(ltype, quoted=T.unsafe(nil)); end
+  def on_qsymbols_new(*args); end
 
-  def identify_string_dvar(); end
+  def on_qwords_add(*args); end
 
-  def indent(); end
+  def on_qwords_beg(tok); end
 
-  def initialize_input(); end
+  def on_qwords_new(*args); end
 
-  def lex(); end
+  def on_rational(tok); end
 
-  def lex_init(); end
+  def on_rbrace(tok); end
 
-  def lex_int2(); end
+  def on_rbracket(tok); end
 
-  def line_no(); end
+  def on_redo(*args); end
 
-  def peek(i=T.unsafe(nil)); end
+  def on_regexp_add(*args); end
 
-  def peek_equal?(str); end
+  def on_regexp_beg(tok); end
 
-  def peek_match?(regexp); end
+  def on_regexp_end(tok); end
 
-  def prompt(); end
+  def on_regexp_literal(*args); end
 
-  def read_escape(); end
+  def on_regexp_new(*args); end
 
-  def readed_auto_clean_up(); end
+  def on_rescue(*args); end
 
-  def readed_auto_clean_up=(readed_auto_clean_up); end
+  def on_rescue_mod(*args); end
 
-  def seek(); end
+  def on_rest_param(*args); end
 
-  def set_input(io, p=T.unsafe(nil), &block); end
+  def on_retry(*args); end
 
-  def set_prompt(p=T.unsafe(nil), &block); end
+  def on_return(*args); end
 
-  def skip_space(); end
+  def on_return0(*args); end
 
-  def skip_space=(skip_space); end
+  def on_rparen(tok); end
 
-  def token(); end
+  def on_sclass(*args); end
 
-  def ungetc(c=T.unsafe(nil)); end
-  DEINDENT_CLAUSE = ::T.let(nil, ::T.untyped)
-  DLtype2Token = ::T.let(nil, ::T.untyped)
-  ENINDENT_CLAUSE = ::T.let(nil, ::T.untyped)
-  Ltype2Token = ::T.let(nil, ::T.untyped)
-  PERCENT_LTYPE = ::T.let(nil, ::T.untyped)
-  PERCENT_PAREN = ::T.let(nil, ::T.untyped)
-end
+  def on_semicolon(tok); end
 
-class RubyLex::AlreadyDefinedToken
-end
+  def on_sp(tok); end
 
-class RubyLex::AlreadyDefinedToken
-end
+  def on_stmts_add(*args); end
 
-class RubyLex::SyntaxError
-end
+  def on_stmts_new(*args); end
 
-class RubyLex::SyntaxError
-end
+  def on_string_add(*args); end
 
-class RubyLex::TerminateLineInput
-end
+  def on_string_concat(*args); end
 
-class RubyLex::TerminateLineInput
-end
+  def on_string_content(*args); end
 
-class RubyLex::TkReading2TokenDuplicateError
-end
+  def on_string_dvar(*args); end
 
-class RubyLex::TkReading2TokenDuplicateError
-end
+  def on_string_embexpr(*args); end
 
-class RubyLex::TkReading2TokenNoKey
-end
+  def on_string_literal(*args); end
 
-class RubyLex::TkReading2TokenNoKey
-end
+  def on_super(*args); end
 
-class RubyLex::TkSymbol2TokenNoKey
-end
+  def on_symbeg(tok); end
 
-class RubyLex::TkSymbol2TokenNoKey
-end
+  def on_symbol(*args); end
 
-class RubyLex
-  extend ::Exception2MessageMapper
-  def self.debug?(); end
+  def on_symbol_literal(*args); end
 
-  def self.debug_level(); end
+  def on_symbols_add(*args); end
 
-  def self.debug_level=(debug_level); end
+  def on_symbols_beg(tok); end
 
-  def self.included(mod); end
-end
+  def on_symbols_new(*args); end
 
-module RubyToken
-  def Token(token, value=T.unsafe(nil)); end
-  EXPR_ARG = ::T.let(nil, ::T.untyped)
-  EXPR_BEG = ::T.let(nil, ::T.untyped)
-  EXPR_CLASS = ::T.let(nil, ::T.untyped)
-  EXPR_DOT = ::T.let(nil, ::T.untyped)
-  EXPR_END = ::T.let(nil, ::T.untyped)
-  EXPR_FNAME = ::T.let(nil, ::T.untyped)
-  EXPR_MID = ::T.let(nil, ::T.untyped)
-  TkReading2Token = ::T.let(nil, ::T.untyped)
-  TkSymbol2Token = ::T.let(nil, ::T.untyped)
-  TokenDefinitions = ::T.let(nil, ::T.untyped)
-end
+  def on_tlambda(tok); end
 
-class RubyToken::TkALIAS
-end
+  def on_tlambeg(tok); end
 
-class RubyToken::TkALIAS
-end
+  def on_top_const_field(*args); end
 
-class RubyToken::TkAMPER
-end
+  def on_top_const_ref(*args); end
 
-class RubyToken::TkAMPER
-end
+  def on_tstring_beg(tok); end
 
-class RubyToken::TkAND
-end
+  def on_tstring_content(tok); end
 
-class RubyToken::TkAND
-end
+  def on_tstring_end(tok); end
 
-class RubyToken::TkANDOP
-end
+  def on_unary(*args); end
 
-class RubyToken::TkANDOP
-end
+  def on_undef(*args); end
 
-class RubyToken::TkAREF
-end
+  def on_unless(*args); end
 
-class RubyToken::TkAREF
-end
+  def on_unless_mod(*args); end
 
-class RubyToken::TkASET
-end
+  def on_until(*args); end
 
-class RubyToken::TkASET
-end
+  def on_until_mod(*args); end
 
-class RubyToken::TkASSIGN
-end
+  def on_var_alias(*args); end
 
-class RubyToken::TkASSIGN
-end
+  def on_var_field(*args); end
 
-class RubyToken::TkASSOC
-end
+  def on_var_ref(*args); end
 
-class RubyToken::TkASSOC
-end
+  def on_vcall(*args); end
 
-class RubyToken::TkAT
-end
+  def on_void_stmt(*args); end
 
-class RubyToken::TkAT
-end
+  def on_when(*args); end
 
-class RubyToken::TkBACKQUOTE
-end
+  def on_while(*args); end
 
-class RubyToken::TkBACKQUOTE
-end
+  def on_while_mod(*args); end
 
-class RubyToken::TkBACKSLASH
-end
+  def on_word_add(*args); end
 
-class RubyToken::TkBACKSLASH
-end
+  def on_word_new(*args); end
 
-class RubyToken::TkBACK_REF
-end
+  def on_words_add(*args); end
 
-class RubyToken::TkBACK_REF
-end
+  def on_words_beg(tok); end
 
-class RubyToken::TkBEGIN
-end
+  def on_words_new(*args); end
 
-class RubyToken::TkBEGIN
-end
+  def on_words_sep(tok); end
 
-class RubyToken::TkBITAND
-end
+  def on_xstring_add(*args); end
 
-class RubyToken::TkBITAND
-end
+  def on_xstring_literal(*args); end
 
-class RubyToken::TkBITNOT
-end
+  def on_xstring_new(*args); end
 
-class RubyToken::TkBITNOT
-end
+  def on_yield(*args); end
 
-class RubyToken::TkBITOR
-end
+  def on_yield0(*args); end
 
-class RubyToken::TkBITOR
+  def on_zsuper(*args); end
 end
 
-class RubyToken::TkBITXOR
-end
+class Ripper::TokenPattern
+  def initialize(pattern); end
 
-class RubyToken::TkBITXOR
-end
+  def match(str); end
 
-class RubyToken::TkBREAK
+  def match_list(tokens); end
+  MAP = ::T.let(nil, ::T.untyped)
 end
 
-class RubyToken::TkBREAK
+class Ripper::TokenPattern::CompileError
 end
 
-class RubyToken::TkCASE
+class Ripper::TokenPattern::CompileError
 end
 
-class RubyToken::TkCASE
+class Ripper::TokenPattern::Error
 end
 
-class RubyToken::TkCLASS
+class Ripper::TokenPattern::Error
 end
 
-class RubyToken::TkCLASS
-end
+class Ripper::TokenPattern::MatchData
+  def initialize(tokens, match); end
 
-class RubyToken::TkCMP
+  def string(n=T.unsafe(nil)); end
 end
 
-class RubyToken::TkCMP
+class Ripper::TokenPattern::MatchData
 end
 
-class RubyToken::TkCOLON
+class Ripper::TokenPattern::MatchError
 end
 
-class RubyToken::TkCOLON
+class Ripper::TokenPattern::MatchError
 end
 
-class RubyToken::TkCOLON2
+class Ripper::TokenPattern
+  def self.compile(*arg, **arg1); end
 end
 
-class RubyToken::TkCOLON2
-end
+class Ripper
+  def self.dedent_string(arg, arg1); end
 
-class RubyToken::TkCOLON3
-end
+  def self.lex_state_name(arg); end
 
-class RubyToken::TkCOLON3
+  def self.token_match(src, pattern); end
 end
 
-class RubyToken::TkCOMMA
-end
+module RuboCop::AST::CollectionNode
+  def compact_blank(*args, **arg, &block); end
 
-class RubyToken::TkCOMMA
-end
+  def compact_blank!(*args, **arg, &block); end
 
-class RubyToken::TkCOMMENT
-end
+  def deconstruct(*args, **arg, &block); end
 
-class RubyToken::TkCOMMENT
-end
+  def exclude?(*args, **arg, &block); end
 
-class RubyToken::TkCONSTANT
-end
+  def excluding(*args, **arg, &block); end
 
-class RubyToken::TkCONSTANT
-end
+  def extract_options!(*args, **arg, &block); end
 
-class RubyToken::TkCVAR
-end
+  def fifth(*args, **arg, &block); end
 
-class RubyToken::TkCVAR
-end
+  def filter_map(*args, **arg, &block); end
 
-class RubyToken::TkDEF
-end
+  def forty_two(*args, **arg, &block); end
 
-class RubyToken::TkDEF
-end
+  def fourth(*args, **arg, &block); end
 
-class RubyToken::TkDEFINED
-end
+  def from(*args, **arg, &block); end
 
-class RubyToken::TkDEFINED
-end
+  def including(*args, **arg, &block); end
 
-class RubyToken::TkDIV
-end
+  def index_by(*args, **arg, &block); end
 
-class RubyToken::TkDIV
-end
+  def index_with(*args, **arg, &block); end
 
-class RubyToken::TkDO
-end
+  def intersect?(*args, **arg, &block); end
 
-class RubyToken::TkDO
-end
+  def intersection(*args, **arg, &block); end
 
-class RubyToken::TkDOLLAR
-end
+  def many?(*args, **arg, &block); end
 
-class RubyToken::TkDOLLAR
-end
+  def pick(*args, **arg, &block); end
 
-class RubyToken::TkDOT
-end
+  def pluck(*args, **arg, &block); end
 
-class RubyToken::TkDOT
-end
+  def second(*args, **arg, &block); end
 
-class RubyToken::TkDOT2
-end
+  def second_to_last(*args, **arg, &block); end
 
-class RubyToken::TkDOT2
-end
+  def tally(*args, **arg, &block); end
 
-class RubyToken::TkDOT3
-end
+  def third(*args, **arg, &block); end
 
-class RubyToken::TkDOT3
-end
+  def third_to_last(*args, **arg, &block); end
 
-class RubyToken::TkDREGEXP
-end
+  def to(*args, **arg, &block); end
 
-class RubyToken::TkDREGEXP
-end
+  def to_default_s(*args, **arg, &block); end
 
-class RubyToken::TkDSTRING
-end
+  def to_formatted_s(*args, **arg, &block); end
 
-class RubyToken::TkDSTRING
-end
+  def to_sentence(*args, **arg, &block); end
 
-class RubyToken::TkDXSTRING
-end
+  def to_xml(*args, **arg, &block); end
 
-class RubyToken::TkDXSTRING
+  def without(*args, **arg, &block); end
 end
 
-class RubyToken::TkELSE
-end
+class RuboCop::AST::Node
+  def arch_variable?(param0=T.unsafe(nil)); end
 
-class RubyToken::TkELSE
-end
+  def begin_block?(param0=T.unsafe(nil)); end
 
-class RubyToken::TkELSIF
-end
+  def block_args(param0=T.unsafe(nil)); end
 
-class RubyToken::TkELSIF
-end
+  def block_body(param0=T.unsafe(nil)); end
 
-class RubyToken::TkEND
-end
+  def cask_block?(param0=T.unsafe(nil)); end
 
-class RubyToken::TkEND
-end
+  def key_node(param0=T.unsafe(nil)); end
 
-class RubyToken::TkEND_OF_SCRIPT
-end
+  def method_node(param0=T.unsafe(nil)); end
 
-class RubyToken::TkEND_OF_SCRIPT
-end
+  def on_system_block?(param0=T.unsafe(nil)); end
 
-class RubyToken::TkENSURE
+  def val_node(param0=T.unsafe(nil)); end
 end
 
-class RubyToken::TkENSURE
+class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkEQ
+class RuboCop::AST::NodePattern::Parser
+  Racc_debug_parser = ::T.let(nil, ::T.untyped)
 end
 
-class RubyToken::TkEQ
+module RuboCop::AST::NodePattern::Sets
+  SET_ARM_INTEL = ::T.let(nil, ::T.untyped)
+  SET_BASH_COMPLETION_ZSH_COMPLETION_FISH_COMPLETION = ::T.let(nil, ::T.untyped)
+  SET_BUILD_RECOMMENDED_TEST_OPTIONAL = ::T.let(nil, ::T.untyped)
+  SET_DEPENDS_ON_USES_FROM_MACOS = ::T.let(nil, ::T.untyped)
+  SET_INCLUDE_WITH_WITHOUT = ::T.let(nil, ::T.untyped)
+  SET_MAC_LINUX = ::T.let(nil, ::T.untyped)
+  SET_ON_ARM_ON_INTEL_ON_SONOMA_ETC = ::T.let(nil, ::T.untyped)
+  SET_ON_INTEL_ON_ARM = ::T.let(nil, ::T.untyped)
+  SET_OR_NEWER_OR_OLDER = ::T.let(nil, ::T.untyped)
+  SET_SYSTEM_SHELL_OUTPUT_PIPE_OUTPUT = ::T.let(nil, ::T.untyped)
+  SET_WITH_WITHOUT = ::T.let(nil, ::T.untyped)
+  SET____ETC_4 = ::T.let(nil, ::T.untyped)
 end
 
-class RubyToken::TkEQQ
-end
+class RuboCop::Cask::AST::Stanza
+  def app?(); end
 
-class RubyToken::TkEQQ
-end
+  def appcast?(); end
 
-class RubyToken::TkError
-end
+  def arch?(); end
 
-class RubyToken::TkError
-end
+  def artifact?(); end
 
-class RubyToken::TkFALSE
-end
+  def audio_unit_plugin?(); end
 
-class RubyToken::TkFALSE
-end
+  def auto_updates?(); end
 
-class RubyToken::TkFID
-end
+  def binary?(); end
 
-class RubyToken::TkFID
-end
+  def caveats?(); end
 
-class RubyToken::TkFLOAT
-end
+  def colorpicker?(); end
 
-class RubyToken::TkFLOAT
-end
+  def conflicts_with?(); end
 
-class RubyToken::TkFOR
-end
+  def container?(); end
 
-class RubyToken::TkFOR
-end
+  def depends_on?(); end
 
-class RubyToken::TkGEQ
-end
+  def desc?(); end
 
-class RubyToken::TkGEQ
-end
+  def dictionary?(); end
 
-class RubyToken::TkGT
-end
+  def font?(); end
 
-class RubyToken::TkGT
-end
+  def homepage?(); end
 
-class RubyToken::TkGVAR
-end
+  def input_method?(); end
 
-class RubyToken::TkGVAR
-end
+  def installer?(); end
 
-class RubyToken::TkIDENTIFIER
-end
+  def internet_plugin?(); end
 
-class RubyToken::TkIDENTIFIER
-end
+  def keyboard_layout?(); end
 
-class RubyToken::TkIF
-end
+  def language?(); end
 
-class RubyToken::TkIF
-end
+  def livecheck?(); end
 
-class RubyToken::TkIF_MOD
-end
+  def manpage?(); end
 
-class RubyToken::TkIF_MOD
-end
+  def mdimporter?(); end
 
-class RubyToken::TkIN
-end
+  def name?(); end
 
-class RubyToken::TkIN
-end
+  def on_arch_conditional?(); end
 
-class RubyToken::TkINTEGER
-end
+  def on_arm?(); end
 
-class RubyToken::TkINTEGER
-end
+  def on_big_sur?(); end
 
-class RubyToken::TkIVAR
-end
+  def on_catalina?(); end
 
-class RubyToken::TkIVAR
-end
+  def on_el_capitan?(); end
 
-class RubyToken::TkId
-  def initialize(seek, line_no, char_no, name); end
+  def on_high_sierra?(); end
 
-  def name(); end
-end
+  def on_intel?(); end
 
-class RubyToken::TkId
-end
+  def on_mojave?(); end
 
-class RubyToken::TkLBRACE
-end
+  def on_monterey?(); end
 
-class RubyToken::TkLBRACE
-end
+  def on_sierra?(); end
 
-class RubyToken::TkLBRACK
-end
+  def on_sonoma?(); end
 
-class RubyToken::TkLBRACK
-end
+  def on_ventura?(); end
 
-class RubyToken::TkLEQ
-end
+  def pkg?(); end
 
-class RubyToken::TkLEQ
-end
+  def postflight?(); end
 
-class RubyToken::TkLPAREN
-end
+  def preflight?(); end
 
-class RubyToken::TkLPAREN
-end
+  def prefpane?(); end
 
-class RubyToken::TkLSHFT
-end
+  def qlplugin?(); end
 
-class RubyToken::TkLSHFT
-end
+  def screen_saver?(); end
 
-class RubyToken::TkLT
-end
+  def service?(); end
 
-class RubyToken::TkLT
-end
+  def sha256?(); end
 
-class RubyToken::TkMATCH
-end
+  def stage_only?(); end
 
-class RubyToken::TkMATCH
-end
+  def suite?(); end
 
-class RubyToken::TkMINUS
-end
+  def uninstall?(); end
 
-class RubyToken::TkMINUS
-end
+  def uninstall_postflight?(); end
 
-class RubyToken::TkMOD
-end
+  def uninstall_preflight?(); end
 
-class RubyToken::TkMOD
-end
+  def url?(); end
 
-class RubyToken::TkMODULE
-end
+  def version?(); end
 
-class RubyToken::TkMODULE
-end
+  def vst3_plugin?(); end
 
-class RubyToken::TkMULT
-end
+  def vst_plugin?(); end
 
-class RubyToken::TkMULT
+  def zap?(); end
 end
 
-class RubyToken::TkNEQ
+class RuboCop::CommentConfig::ConfigDisabledCopDirectiveComment::Expression
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkNEQ
+class RuboCop::CommentConfig::ConfigDisabledCopDirectiveComment::Loc
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkNEXT
+class RuboCop::CommentConfig::CopAnalysis
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkNEXT
+class RuboCop::Config::CopConfig
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkNIL
+class RuboCop::Cop::Base::InvestigationReport
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkNIL
+module RuboCop::Cop::Cask::CaskHelp
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNL
+module RuboCop::Cop::Cask::CaskHelp
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-class RubyToken::TkNL
+class RuboCop::Cop::Cask::Desc
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNMATCH
+class RuboCop::Cop::Cask::HomepageUrlTrailingSlash
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNMATCH
+class RuboCop::Cop::Cask::NoOverrides
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNOT
+module RuboCop::Cop::Cask::OnDescStanza
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNOT
+module RuboCop::Cop::Cask::OnHomepageStanza
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNOTOP
+class RuboCop::Cop::Cask::OnSystemConditionals
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNOTOP
+module RuboCop::Cop::Cask::OnUrlStanza
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNTH_REF
+class RuboCop::Cop::Cask::StanzaGrouping
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNTH_REF
+class RuboCop::Cop::Cask::StanzaOrder
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNode
-  def node(); end
+class RuboCop::Cop::Cask::Url
+  include ::RuboCop::Cop::CommentsHelp
 end
 
-class RubyToken::TkNode
+class RuboCop::Cop::Cask::Variables
+  include ::RuboCop::Cop::CommentsHelp
+  def variable_assignment(param0); end
 end
 
-class RubyToken::TkOPASGN
-  def initialize(seek, line_no, char_no, op); end
-
-  def op(); end
+class RuboCop::Cop::Commissioner::InvestigationReport
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkOPASGN
-end
+class RuboCop::Cop::Cop
+  def highlights(); end
 
-class RubyToken::TkOR
+  def messages(); end
 end
 
-class RubyToken::TkOR
+class RuboCop::Cop::Cop::Correction
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkOROP
+class RuboCop::Cop::FormulaAudit::ComponentsOrder
+  def depends_on_node?(param0=T.unsafe(nil)); end
 end
 
-class RubyToken::TkOROP
-end
+class RuboCop::Cop::FormulaAudit::DependencyOrder
+  def build_with_dependency_node(param0); end
 
-class RubyToken::TkOp
-  def name(); end
+  def buildtime_dependency?(param0); end
 
-  def name=(name); end
-end
+  def dependency_name_node(param0); end
 
-class RubyToken::TkOp
-end
+  def depends_on_node?(param0=T.unsafe(nil)); end
 
-class RubyToken::TkPLUS
-end
+  def negate_normal_dependency?(param0); end
 
-class RubyToken::TkPLUS
-end
+  def optional_dependency?(param0); end
 
-class RubyToken::TkPOW
-end
+  def recommended_dependency?(param0); end
 
-class RubyToken::TkPOW
-end
+  def test_dependency?(param0); end
 
-class RubyToken::TkQUESTION
+  def uses_from_macos_node?(param0=T.unsafe(nil)); end
 end
 
-class RubyToken::TkQUESTION
+class RuboCop::Cop::FormulaAudit::DeprecateDisableDate
+  def date(param0); end
 end
 
-class RubyToken::TkRBRACE
+class RuboCop::Cop::FormulaAudit::DeprecateDisableReason
+  def reason(param0); end
 end
 
-class RubyToken::TkRBRACE
-end
+class RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL
+  def correctable_shell_completion_node(param0); end
 
-class RubyToken::TkRBRACK
+  def shell_completion_node(param0); end
 end
 
-class RubyToken::TkRBRACK
+class RuboCop::Cop::FormulaAudit::GitUrls
+  def url_has_revision?(param0=T.unsafe(nil)); end
 end
 
-class RubyToken::TkRD_COMMENT
+class RuboCop::Cop::FormulaAudit::Licenses
+  def license_exception?(param0=T.unsafe(nil)); end
 end
 
-class RubyToken::TkRD_COMMENT
-end
+class RuboCop::Cop::FormulaAudit::Miscellaneous
+  def conditional_dependencies(param0); end
 
-class RubyToken::TkREDO
-end
+  def destructure_hash(param0=T.unsafe(nil)); end
 
-class RubyToken::TkREDO
-end
+  def formula_path_strings(param0, param1); end
 
-class RubyToken::TkREGEXP
-end
+  def hash_dep(param0=T.unsafe(nil)); end
 
-class RubyToken::TkREGEXP
+  def languageNodeModule?(param0); end
 end
 
-class RubyToken::TkRESCUE
+class RuboCop::Cop::FormulaAudit::OptionDeclarations
+  def depends_on_build_with(param0); end
 end
 
-class RubyToken::TkRESCUE
+class RuboCop::Cop::FormulaAudit::Patches
+  def patch_data?(param0); end
 end
 
-class RubyToken::TkRETRY
+class RuboCop::Cop::FormulaAudit::Test
+  def test_calls(param0); end
 end
 
-class RubyToken::TkRETRY
+class RuboCop::Cop::FormulaAudit::Text
+  def prefix_path(param0); end
 end
 
-class RubyToken::TkRETURN
+class RuboCop::Cop::FormulaAuditStrict::GitUrls
+  def url_has_tag?(param0=T.unsafe(nil)); end
 end
 
-class RubyToken::TkRETURN
-end
+class RuboCop::Cop::FormulaAuditStrict::Text
+  def interpolated_share_path_starts_with(param0, param1); end
 
-class RubyToken::TkRPAREN
+  def share_path_starts_with(param0, param1); end
 end
 
-class RubyToken::TkRPAREN
-end
+class RuboCop::Cop::FormulaCop
+  def dependency_name_hash_match?(param0, param1); end
 
-class RubyToken::TkRSHFT
-end
+  def dependency_type_hash_match?(param0, param1); end
 
-class RubyToken::TkRSHFT
-end
+  def initialize(*args, **arg, &blk); end
 
-class RubyToken::TkSELF
-end
+  def required_dependency?(param0); end
 
-class RubyToken::TkSELF
+  def required_dependency_name?(param0, param1); end
 end
 
-class RubyToken::TkSEMICOLON
+class RuboCop::Cop::FormulaCop
+  extend ::T::Private::Abstract::Hooks
+  extend ::T::InterfaceWrapper::Helpers
 end
 
-class RubyToken::TkSEMICOLON
+class RuboCop::Cop::HashShorthandSyntax::DefNode
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkSPACE
+class RuboCop::Cop::HashTransformMethod::Autocorrection
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkSPACE
+class RuboCop::Cop::HashTransformMethod::Captures
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkSTAR
+module RuboCop::Cop::HelperFunctions
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-class RubyToken::TkSTAR
+class RuboCop::Cop::Homebrew::MoveToExtendOS
+  def os_check?(param0=T.unsafe(nil)); end
 end
 
-class RubyToken::TkSTRING
+class RuboCop::Cop::IndexMethod::Autocorrection
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkSTRING
+class RuboCop::Cop::IndexMethod::Captures
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkSUPER
+class RuboCop::Cop::Naming::InclusiveLanguage::WordLocation
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkSUPER
-end
+module RuboCop::Cop::OnSystemConditionalsHelper
+  def hardware_cpu_search(param0, method:); end
 
-class RubyToken::TkSYMBEG
-end
+  def if_arch_node_search(param0, arch:); end
 
-class RubyToken::TkSYMBEG
-end
+  def if_base_os_node_search(param0, base_os:); end
 
-class RubyToken::TkSYMBOL
-end
+  def if_macos_version_node_search(param0, os_version:); end
 
-class RubyToken::TkSYMBOL
-end
+  def macos_version_comparison_search(param0, os_version:); end
 
-class RubyToken::TkTHEN
-end
+  def on_macos_version_method_call(param0=T.unsafe(nil), on_method:); end
 
-class RubyToken::TkTHEN
+  def on_system_method_call(param0=T.unsafe(nil)); end
 end
 
-class RubyToken::TkTRUE
+class RuboCop::Cop::VariableForce::AssignmentReference
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkTRUE
+class RuboCop::Cop::VariableForce::Branch::Base
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkUMINUS
+class RuboCop::Cop::VariableForce::VariableReference
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkUMINUS
+class RuboCop::Formatter::HTMLFormatter::Color
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkUNDEF
+class RuboCop::Formatter::HTMLFormatter::FileOffenses
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkUNDEF
+class RuboCop::Formatter::HTMLFormatter::Summary
+  def self.keyword_init?(); end
 end
 
-class RubyToken::TkUNLESS
-end
+module RuboCop::RSpec::ExpectOffense
+  def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end
 
-class RubyToken::TkUNLESS
-end
+  def expect_no_corrections(); end
 
-class RubyToken::TkUNLESS_MOD
-end
+  def expect_no_offenses(source, file=T.unsafe(nil)); end
 
-class RubyToken::TkUNLESS_MOD
-end
+  def expect_offense(source, file=T.unsafe(nil), severity: T.unsafe(nil), chomp: T.unsafe(nil), **replacements); end
 
-class RubyToken::TkUNTIL
-end
+  def format_offense(source, **replacements); end
 
-class RubyToken::TkUNTIL
-end
+  def parse_annotations(source, raise_error: T.unsafe(nil), **replacements); end
 
-class RubyToken::TkUNTIL_MOD
-end
+  def parse_processed_source(source, file=T.unsafe(nil)); end
 
-class RubyToken::TkUNTIL_MOD
+  def set_formatter_options(); end
 end
 
-class RubyToken::TkUPLUS
-end
+class RuboCop::RSpec::ExpectOffense::AnnotatedSource
+  def ==(other); end
 
-class RubyToken::TkUPLUS
-end
+  def annotations(); end
 
-class RubyToken::TkUnknownChar
-  def initialize(seek, line_no, char_no, id); end
+  def initialize(lines, annotations); end
 
-  def name(); end
-end
+  def lines(); end
 
-class RubyToken::TkUnknownChar
-end
+  def match_annotations?(other); end
 
-class RubyToken::TkVal
-  def initialize(seek, line_no, char_no, value=T.unsafe(nil)); end
+  def plain_source(); end
 
-  def value(); end
+  def with_offense_annotations(offenses); end
+  ABBREV = ::T.let(nil, ::T.untyped)
+  ANNOTATION_PATTERN = ::T.let(nil, ::T.untyped)
 end
 
-class RubyToken::TkVal
+class RuboCop::RSpec::ExpectOffense::AnnotatedSource
+  def self.parse(annotated_source); end
 end
 
-class RubyToken::TkWHEN
+module RuboCop::RSpec::ExpectOffense
 end
 
-class RubyToken::TkWHEN
+class RuboCop::RSpec::ParallelFormatter
+  def dump_pending(*arg); end
 end
 
-class RubyToken::TkWHILE
+class RuboCop::RSpec::ParallelFormatter
 end
 
-class RubyToken::TkWHILE
-end
+class RubyLex
+  def check_code_block(code, tokens=T.unsafe(nil)); end
 
-class RubyToken::TkWHILE_MOD
-end
+  def check_corresponding_token_depth(lines, line_index); end
 
-class RubyToken::TkWHILE_MOD
-end
+  def check_newline_depth_difference(); end
 
-class RubyToken::TkXSTRING
-end
+  def check_state(code, tokens=T.unsafe(nil), context: T.unsafe(nil)); end
 
-class RubyToken::TkXSTRING
-end
+  def check_string_literal(tokens); end
 
-class RubyToken::TkYIELD
-end
+  def check_termination_in_prev_line(code, context: T.unsafe(nil)); end
 
-class RubyToken::TkYIELD
-end
+  def each_top_level_statement(); end
 
-class RubyToken::Tk__FILE__
-end
+  def find_prev_spaces(line_index); end
 
-class RubyToken::Tk__FILE__
-end
+  def initialize_input(); end
 
-class RubyToken::Tk__LINE__
-end
+  def is_method_calling?(tokens, index); end
 
-class RubyToken::Tk__LINE__
-end
+  def is_the_in_correspond_to_a_for(tokens, index); end
 
-class RubyToken::TkfLBRACE
-end
+  def lex(); end
 
-class RubyToken::TkfLBRACE
-end
+  def process_continue(tokens=T.unsafe(nil)); end
 
-class RubyToken::TkfLBRACK
-end
+  def process_literal_type(tokens=T.unsafe(nil)); end
 
-class RubyToken::TkfLBRACK
-end
+  def process_nesting_level(tokens=T.unsafe(nil)); end
 
-class RubyToken::TkfLPAREN
-end
+  def prompt(); end
 
-class RubyToken::TkfLPAREN
-end
+  def set_auto_indent(context); end
 
-class RubyToken::TklBEGIN
-end
+  def set_input(io, p=T.unsafe(nil), context: T.unsafe(nil), &block); end
+
+  def set_prompt(p=T.unsafe(nil), &block); end
 
-class RubyToken::TklBEGIN
+  def take_corresponding_syntax_to_kw_do(tokens, index); end
+  ERROR_TOKENS = ::T.let(nil, ::T.untyped)
 end
 
-class RubyToken::TklEND
+class RubyLex::TerminateLineInput
+  def initialize(); end
 end
 
-class RubyToken::TklEND
+class RubyLex::TerminateLineInput
 end
 
-class RubyToken::Token
-  def char_no(); end
+class RubyLex
+  def self.compile_with_errors_suppressed(code, line_no: T.unsafe(nil)); end
 
-  def initialize(seek, line_no, char_no); end
+  def self.ripper_lex_without_warning(code, context: T.unsafe(nil)); end
+end
 
-  def line_no(); end
+class RubyVM::AbstractSyntaxTree::Node
+  def node_id(); end
 
-  def seek(); end
-end
+  def pretty_print_children(q, names=T.unsafe(nil)); end
 
-class RubyToken::Token
-end
+  def script_lines(); end
 
-module RubyToken
-  def self.def_token(token_n, super_token=T.unsafe(nil), reading=T.unsafe(nil), *opts); end
+  def source(); end
 end
 
-class RubyVM::AbstractSyntaxTree::Node
-  def pretty_print_children(q, names=T.unsafe(nil)); end
+class RubyVM::InstructionSequence
+  def script_lines(); end
 end
 
 module RubyVM::MJIT
@@ -7920,8 +10814,25 @@ module RubyVM::MJIT
   def self.resume(); end
 end
 
+module RubyVM::YJIT
+end
+
+module RubyVM::YJIT
+  def self.enabled?(); end
+
+  def self.reset_stats!(); end
+
+  def self.runtime_stats(); end
+
+  def self.simulate_oom!(); end
+
+  def self.stats_enabled?(); end
+end
+
 class RubyVM
-  def self.resolve_feature_path(arg); end
+  def self.keep_script_lines(); end
+
+  def self.keep_script_lines=(keep_script_lines); end
 end
 
 ScanError = StringScanner::Error
@@ -7954,12 +10865,17 @@ class SimpleCov::LinesClassifier
   NOT_RELEVANT = ::T.let(nil, ::T.untyped)
 end
 
+class SimpleDelegator
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
 module Singleton
   def _dump(depth=T.unsafe(nil)); end
 
   def clone(); end
 
   def dup(); end
+  VERSION = ::T.let(nil, ::T.untyped)
 end
 
 module Singleton::SingletonClassMethods
@@ -7978,6 +10894,7 @@ class Socket
   AF_CNT = ::T.let(nil, ::T.untyped)
   AF_COIP = ::T.let(nil, ::T.untyped)
   AF_DATAKIT = ::T.let(nil, ::T.untyped)
+  AF_DECnet = ::T.let(nil, ::T.untyped)
   AF_DLI = ::T.let(nil, ::T.untyped)
   AF_E164 = ::T.let(nil, ::T.untyped)
   AF_ECMA = ::T.let(nil, ::T.untyped)
@@ -8017,7 +10934,6 @@ class Socket
   IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
   IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
   IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped)
-  IP_DONTFRAG = ::T.let(nil, ::T.untyped)
   IP_PORTRANGE = ::T.let(nil, ::T.untyped)
   IP_RECVDSTADDR = ::T.let(nil, ::T.untyped)
   IP_RECVIF = ::T.let(nil, ::T.untyped)
@@ -8033,6 +10949,7 @@ class Socket
   PF_CNT = ::T.let(nil, ::T.untyped)
   PF_COIP = ::T.let(nil, ::T.untyped)
   PF_DATAKIT = ::T.let(nil, ::T.untyped)
+  PF_DECnet = ::T.let(nil, ::T.untyped)
   PF_DLI = ::T.let(nil, ::T.untyped)
   PF_ECMA = ::T.let(nil, ::T.untyped)
   PF_HYLINK = ::T.let(nil, ::T.untyped)
@@ -8070,6 +10987,7 @@ module Socket::Constants
   AF_CNT = ::T.let(nil, ::T.untyped)
   AF_COIP = ::T.let(nil, ::T.untyped)
   AF_DATAKIT = ::T.let(nil, ::T.untyped)
+  AF_DECnet = ::T.let(nil, ::T.untyped)
   AF_DLI = ::T.let(nil, ::T.untyped)
   AF_E164 = ::T.let(nil, ::T.untyped)
   AF_ECMA = ::T.let(nil, ::T.untyped)
@@ -8109,7 +11027,6 @@ module Socket::Constants
   IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
   IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
   IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped)
-  IP_DONTFRAG = ::T.let(nil, ::T.untyped)
   IP_PORTRANGE = ::T.let(nil, ::T.untyped)
   IP_RECVDSTADDR = ::T.let(nil, ::T.untyped)
   IP_RECVIF = ::T.let(nil, ::T.untyped)
@@ -8125,6 +11042,7 @@ module Socket::Constants
   PF_CNT = ::T.let(nil, ::T.untyped)
   PF_COIP = ::T.let(nil, ::T.untyped)
   PF_DATAKIT = ::T.let(nil, ::T.untyped)
+  PF_DECnet = ::T.let(nil, ::T.untyped)
   PF_DLI = ::T.let(nil, ::T.untyped)
   PF_ECMA = ::T.let(nil, ::T.untyped)
   PF_HYLINK = ::T.let(nil, ::T.untyped)
@@ -8256,24 +11174,45 @@ class String
   def to_nfkd(); end
 end
 
+class StringIO
+  def set_encoding_by_bom(); end
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class StringIO
+  def self.new(*arg); end
+end
+
 class StringScanner
   def bol?(); end
 
+  def fixed_anchor?(); end
+
   def initialize(*arg); end
   Id = ::T.let(nil, ::T.untyped)
   Version = ::T.let(nil, ::T.untyped)
 end
 
 class Struct
+  def deconstruct(); end
+
+  def deconstruct_keys(arg); end
+
   def filter(*arg); end
 end
 
+class Struct
+  def self.new(*arg); end
+end
+
 module Superenv
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
 class Symbol
+  def name(); end
+
   def to_msgpack_ext(); end
 end
 
@@ -8284,6 +11223,7 @@ end
 
 class Tempfile
   def _close(); end
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
 end
 
 class Tempfile::Remover
@@ -8295,6 +11235,30 @@ end
 class Tempfile::Remover
 end
 
+class Test::Helper::OutputAsTTY::Output
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
+class Thread
+  def native_thread_id(); end
+end
+
+class Thread::Backtrace
+  def self.limit(); end
+end
+
+class Thread::Queue
+  def initialize(*arg); end
+end
+
+class Thread
+  def self.ignore_deadlock(); end
+
+  def self.ignore_deadlock=(ignore_deadlock); end
+
+  def self.new(*arg); end
+end
+
 class Time
   def compare_without_coercion(arg); end
 
@@ -8308,12 +11272,14 @@ class Time
 end
 
 class Time
-  def self.at_without_coercion(*arg); end
+  def self.at_without_coercion(time, subsec=T.unsafe(nil), unit=T.unsafe(nil), in: T.unsafe(nil)); end
 end
 
-class TracePoint
-  def __enable(arg, arg1); end
+module Timeout
+  VERSION = ::T.let(nil, ::T.untyped)
+end
 
+class TracePoint
   def eval_script(); end
 
   def instruction_sequence(); end
@@ -8321,10 +11287,20 @@ class TracePoint
   def parameters(); end
 end
 
+class TracePoint
+  def self.allow_reentry(); end
+
+  def self.new(*events); end
+end
+
 module Tty
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+module URI
+  TBLENCURICOMP_ = ::T.let(nil, ::T.untyped)
+end
+
 class URI::FTP
   def buffer_open(buf, proxy, options); end
 end
@@ -8345,8 +11321,18 @@ class URI::File
   DEFAULT_PORT = ::T.let(nil, ::T.untyped)
 end
 
+class URI::Generic
+  def decoded_password(); end
+
+  def decoded_user(); end
+end
+
 class URI::HTTP
+  def authority(); end
+
   def buffer_open(buf, proxy, options); end
+
+  def origin(); end
 end
 
 class URI::LDAP
@@ -8406,8 +11392,42 @@ module URI::Util
   def self.make_components_hash(klass, array_hash); end
 end
 
+class URI::WS
+  def request_uri(); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class URI::WS
+end
+
+class URI::WSS
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class URI::WSS
+end
+
 module URI
+  def self.decode_uri_component(str, enc=T.unsafe(nil)); end
+
+  def self.encode_uri_component(str, enc=T.unsafe(nil)); end
+
+  def self.for(scheme, *arguments, default: T.unsafe(nil)); end
+
   def self.get_encoding(label); end
+
+  def self.open(name, *rest, &block); end
+
+  def self.register_scheme(scheme, klass); end
+end
+
+class UnboundMethod
+  def private?(); end
+
+  def protected?(); end
+
+  def public?(); end
 end
 
 module UnicodeNormalize
@@ -8437,6 +11457,10 @@ module UnpackStrategy
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class User
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
 class User
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -8501,7 +11525,7 @@ module Utils
 end
 
 class Version::Parser
-  def initialize(*args, &blk); end
+  def initialize(*args, **arg, &blk); end
 end
 
 class Version::Parser
@@ -8516,6 +11540,8 @@ end
 
 class WeakRef
   def initialize(orig); end
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
 end
 
 module YARDSorbet::Directives
@@ -8551,10 +11577,20 @@ class Zlib::GzipReader
   def initialize(*arg); end
 end
 
+class Zlib::GzipReader
+  def self.zcat(*arg); end
+end
+
 class Zlib::GzipWriter
   def initialize(*arg); end
 end
 
+class Zlib::InProgressError
+end
+
+class Zlib::InProgressError
+end
+
 class Zlib::Inflate
   def initialize(*arg); end
 end
diff --git a/Library/Homebrew/sorbet/rbi/todo.rbi b/Library/Homebrew/sorbet/rbi/todo.rbi
index 8b0c26fed46e8..6680db05d5add 100644
--- a/Library/Homebrew/sorbet/rbi/todo.rbi
+++ b/Library/Homebrew/sorbet/rbi/todo.rbi
@@ -5,6 +5,7 @@
 # typed: false
 
 module ::Nokogiri; end
+module BigDecimal::Deprecation; end
 module T::InterfaceWrapper::Helpers; end
 module T::Private::Abstract::Hooks; end
 module T::Private::Methods::MethodHooks; end