diff --git a/Library/Homebrew/Gemfile b/Library/Homebrew/Gemfile
index 119817d990..dbcb173e03 100644
--- a/Library/Homebrew/Gemfile
+++ b/Library/Homebrew/Gemfile
@@ -13,8 +13,8 @@ gem "rspec-retry", require: false
 gem "rspec-wait", require: false
 gem "rubocop"
 gem "simplecov", require: false
-gem "sorbet", "0.5.5823"
-gem "sorbet-runtime", "0.5.5823"
+gem "sorbet"
+gem "sorbet-runtime"
 gem "tapioca"
 
 # vendored gems
diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock
index 917271ed76..28e6523270 100644
--- a/Library/Homebrew/Gemfile.lock
+++ b/Library/Homebrew/Gemfile.lock
@@ -120,10 +120,10 @@ GEM
       docile (~> 1.1)
       simplecov-html (~> 0.11)
     simplecov-html (0.12.2)
-    sorbet (0.5.5823)
-      sorbet-static (= 0.5.5823)
-    sorbet-runtime (0.5.5823)
-    sorbet-static (0.5.5823-universal-darwin-14)
+    sorbet (0.5.5866)
+      sorbet-static (= 0.5.5866)
+    sorbet-runtime (0.5.5866)
+    sorbet-static (0.5.5866-universal-darwin-14)
     tapioca (0.4.1)
       parlour (>= 2.1.0)
       pry (>= 0.12.2)
@@ -163,8 +163,8 @@ DEPENDENCIES
   rubocop-rspec
   ruby-macho
   simplecov
-  sorbet (= 0.5.5823)
-  sorbet-runtime (= 0.5.5823)
+  sorbet
+  sorbet-runtime
   tapioca
 
 BUNDLED WITH
diff --git a/Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.2.rbi b/Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.2.rbi
index 47ac6bc2cf..7ef5c1e222 100644
--- a/Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.2.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `activesupport` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: false
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi
index bdfeff7155..682e2cc912 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ast` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -7,7 +8,7 @@ module AST
 end
 
 class AST::Node
-  def initialize(type, children = _, properties = _); end
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
 
   def +(array); end
   def <<(element); end
@@ -19,14 +20,14 @@ class AST::Node
   def dup; end
   def eql?(other); end
   def hash; end
-  def inspect(indent = _); end
+  def inspect(indent = T.unsafe(nil)); end
   def to_a; end
   def to_ast; end
-  def to_s(indent = _); end
-  def to_sexp(indent = _); end
+  def to_s(indent = T.unsafe(nil)); end
+  def to_sexp(indent = T.unsafe(nil)); end
   def to_sexp_array; end
   def type; end
-  def updated(type = _, children = _, properties = _); end
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
 
   protected
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.8.rbi b/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.8.rbi
index ec2a9f3d63..8f744f595c 100644
--- a/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.8.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.8.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `bindata` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -11,10 +12,12 @@ module BinData
   private
 
   def trace_message; end
-  def trace_reading(io = _); end
+  def trace_reading(io = T.unsafe(nil)); end
 
-  def self.trace_message; end
-  def self.trace_reading(io = _); end
+  class << self
+    def trace_message; end
+    def trace_reading(io = T.unsafe(nil)); end
+  end
 end
 
 module BinData::AcceptedParametersPlugin
@@ -29,10 +32,10 @@ module BinData::AcceptedParametersPlugin
 end
 
 class BinData::AcceptedParametersPlugin::AcceptedParameters
-  def initialize(ancestor_parameters = _); end
+  def initialize(ancestor_parameters = T.unsafe(nil)); end
 
   def all; end
-  def default(args = _); end
+  def default(args = T.unsafe(nil)); end
   def mandatory(*args); end
   def mutually_exclusive(*args); end
   def optional(*args); end
@@ -42,7 +45,9 @@ class BinData::AcceptedParametersPlugin::AcceptedParameters
   def ensure_valid_names(names); end
   def to_syms(args); end
 
-  def self.invalid_parameter_names; end
+  class << self
+    def invalid_parameter_names; end
+  end
 end
 
 class BinData::Array < ::BinData::Base
@@ -50,7 +55,7 @@ class BinData::Array < ::BinData::Base
   extend(::BinData::DSLMixin)
 
   def <<(*args); end
-  def [](arg1, arg2 = _); end
+  def [](arg1, arg2 = T.unsafe(nil)); end
   def []=(index, value); end
   def assign(array); end
   def at(index); end
@@ -63,17 +68,17 @@ class BinData::Array < ::BinData::Base
   def empty?; end
   def find_index(obj); end
   def find_index_of(obj); end
-  def first(n = _); end
+  def first(n = T.unsafe(nil)); end
   def index(obj); end
   def initialize_instance; end
   def initialize_shared_instance; end
   def insert(index, *objs); end
-  def last(n = _); end
+  def last(n = T.unsafe(nil)); end
   def length; end
   def offset_of(child); end
   def push(*args); end
   def size; end
-  def slice(arg1, arg2 = _); end
+  def slice(arg1, arg2 = T.unsafe(nil)); end
   def snapshot; end
   def to_ary; end
   def unshift(*args); end
@@ -108,20 +113,20 @@ class BinData::Base
   def base_respond_to?(*_); end
   def clear; end
   def debug_name; end
-  def eval_parameter(key, overrides = _); end
+  def eval_parameter(key, overrides = T.unsafe(nil)); end
   def get_parameter(key); end
   def has_parameter?(key); end
   def initialize_instance(*args); end
   def initialize_with_warning(*args); end
   def inspect; end
   def lazy_evaluator; end
-  def new(value = _, parent = _); end
+  def new(value = T.unsafe(nil), parent = T.unsafe(nil)); end
   def num_bytes; end
   def parent; end
   def pretty_print(pp); end
   def read(io, &block); end
   def rel_offset; end
-  def safe_respond_to?(symbol, include_private = _); end
+  def safe_respond_to?(symbol, include_private = T.unsafe(nil)); end
   def to_binary_s(&block); end
   def to_hex(&block); end
   def to_s; end
@@ -142,11 +147,18 @@ class BinData::Base
   def top_level_get(sym); end
   def top_level_set(sym, value); end
 
-  def self.arg_processor(name = _); end
-  def self.auto_call_delayed_io; end
-  def self.bindata_name; end
-  def self.inherited(subclass); end
-  def self.read(io, *args, &block); end
+  class << self
+    def arg_processor(name = T.unsafe(nil)); end
+    def auto_call_delayed_io; end
+    def bindata_name; end
+    def inherited(subclass); end
+    def read(io, *args, &block); end
+
+    private
+
+    def register_subclasses; end
+    def unregister_self; end
+  end
 end
 
 module BinData::Base::AutoCallDelayedIO
@@ -175,7 +187,7 @@ class BinData::BasePrimitive < ::BinData::Base
   def initialize_instance; end
   def initialize_shared_instance; end
   def method_missing(symbol, *args, &block); end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
   def snapshot; end
   def trace_value; end
   def value; end
@@ -188,10 +200,12 @@ class BinData::BasePrimitive < ::BinData::Base
   def sensible_default; end
   def value_to_binary_string(val); end
 
-  def self.bit_aligned; end
-  def self.inherited(subclass); end
-  def self.turn_off_tracing; end
-  def self.turn_on_tracing; end
+  class << self
+    def bit_aligned; end
+    def inherited(subclass); end
+    def turn_off_tracing; end
+    def turn_on_tracing; end
+  end
 end
 
 module BinData::BasePrimitive::AssertPlugin
@@ -243,16 +257,18 @@ class BinData::BitAligned::BitAlignedIO
 end
 
 module BinData::BitField
-  def self.create_clamp_code(nbits, signed); end
-  def self.create_do_num_bytes_code(nbits); end
-  def self.create_dynamic_clamp_code(signed); end
-  def self.create_fixed_clamp_code(nbits, signed); end
-  def self.create_int2uint_code(nbits, signed); end
-  def self.create_nbits_code(nbits); end
-  def self.create_params_code(nbits); end
-  def self.create_uint2int_code(nbits, signed); end
-  def self.define_class(name, nbits, endian, signed = _); end
-  def self.define_methods(bit_class, nbits, endian, signed); end
+  class << self
+    def create_clamp_code(nbits, signed); end
+    def create_do_num_bytes_code(nbits); end
+    def create_dynamic_clamp_code(signed); end
+    def create_fixed_clamp_code(nbits, signed); end
+    def create_int2uint_code(nbits, signed); end
+    def create_nbits_code(nbits); end
+    def create_params_code(nbits); end
+    def create_uint2int_code(nbits, signed); end
+    def define_class(name, nbits, endian, signed = T.unsafe(nil)); end
+    def define_methods(bit_class, nbits, endian, signed); end
+  end
 end
 
 module BinData::BitFieldFactory
@@ -282,7 +298,7 @@ class BinData::Buffer < ::BinData::Base
   def initialize_instance; end
   def method_missing(symbol, *args, &block); end
   def raw_num_bytes; end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
   def snapshot; end
 end
 
@@ -312,7 +328,7 @@ class BinData::Choice < ::BinData::Base
   def initialize_instance; end
   def initialize_shared_instance; end
   def method_missing(symbol, *args, &block); end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
   def selection; end
   def snapshot(*args); end
   def trace_selection; end
@@ -322,8 +338,10 @@ class BinData::Choice < ::BinData::Base
   def current_choice; end
   def instantiate_choice(selection); end
 
-  def self.turn_off_tracing; end
-  def self.turn_on_tracing; end
+  class << self
+    def turn_off_tracing; end
+    def turn_on_tracing; end
+  end
 end
 
 class BinData::ChoiceArgProcessor < ::BinData::BaseArgProcessor
@@ -353,21 +371,23 @@ class BinData::CountBytesRemaining < ::BinData::BasePrimitive
 end
 
 module BinData::DSLMixin
-  def dsl_parser(parser_type = _); end
+  def dsl_parser(parser_type = T.unsafe(nil)); end
   def method_missing(symbol, *args, &block); end
   def to_ary; end
   def to_str; end
 end
 
 class BinData::DSLMixin::DSLBigAndLittleEndianHandler
-  def self.class_with_endian(class_name, endian); end
-  def self.create_subclasses_with_endian(bnl_class); end
-  def self.delegate_field_creation(bnl_class); end
-  def self.fixup_subclass_hierarchy(bnl_class); end
-  def self.handle(bnl_class); end
-  def self.make_class_abstract(bnl_class); end
-  def self.obj_attribute(obj, attr); end
-  def self.override_new_in_class(bnl_class); end
+  class << self
+    def class_with_endian(class_name, endian); end
+    def create_subclasses_with_endian(bnl_class); end
+    def delegate_field_creation(bnl_class); end
+    def fixup_subclass_hierarchy(bnl_class); end
+    def handle(bnl_class); end
+    def make_class_abstract(bnl_class); end
+    def obj_attribute(obj, attr); end
+    def override_new_in_class(bnl_class); end
+  end
 end
 
 class BinData::DSLMixin::DSLFieldParser
@@ -402,7 +422,7 @@ class BinData::DSLMixin::DSLParser
   def initialize(the_class, parser_type); end
 
   def dsl_params; end
-  def endian(endian = _); end
+  def endian(endian = T.unsafe(nil)); end
   def fields; end
   def hide(*args); end
   def method_missing(*args, &block); end
@@ -417,7 +437,7 @@ class BinData::DSLMixin::DSLParser
   def fields?; end
   def hints; end
   def option?(opt); end
-  def parent_attribute(attr, default = _); end
+  def parent_attribute(attr, default = T.unsafe(nil)); end
   def parent_fields; end
   def parse_and_append_field(*args, &block); end
   def parser_abilities; end
@@ -443,7 +463,7 @@ class BinData::DelayedIO < ::BinData::Base
   def num_bytes; end
   def read_now!; end
   def rel_offset; end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
   def snapshot; end
   def write_now!; end
 end
@@ -495,10 +515,12 @@ class BinData::FloatLe < ::BinData::BasePrimitive
 end
 
 module BinData::FloatingPoint
-  def self.create_num_bytes_code(precision); end
-  def self.create_read_code(precision, endian); end
-  def self.create_to_binary_s_code(precision, endian); end
-  def self.define_methods(float_class, precision, endian); end
+  class << self
+    def create_num_bytes_code(precision); end
+    def create_read_code(precision, endian); end
+    def create_to_binary_s_code(precision, endian); end
+    def define_methods(float_class, precision, endian); end
+  end
 end
 
 module BinData::Framework
@@ -519,7 +541,9 @@ module BinData::Framework
 end
 
 module BinData::IO
-  def self.create_string_io(str = _); end
+  class << self
+    def create_string_io(str = T.unsafe(nil)); end
+  end
 end
 
 module BinData::IO::Common
@@ -579,7 +603,7 @@ class BinData::IO::Read
   def accumulate_big_endian_bits; end
   def accumulate_little_endian_bits; end
   def mask(nbits); end
-  def read(n = _); end
+  def read(n = T.unsafe(nil)); end
   def read_big_endian_bits(nbits); end
   def read_little_endian_bits(nbits); end
 end
@@ -611,8 +635,25 @@ module BinData::InitialLengthPlugin
 end
 
 module BinData::Int
-  def self.define_class(name, nbits, endian, signed); end
-  def self.define_methods(int_class, nbits, endian, signed); end
+  class << self
+    def define_class(name, nbits, endian, signed); end
+    def define_methods(int_class, nbits, endian, signed); end
+
+    private
+
+    def bits_per_word(nbits); end
+    def create_clamp_code(nbits, signed); end
+    def create_int2uint_code(nbits); end
+    def create_raw_read_code(nbits, endian, signed); end
+    def create_read_assemble_code(nbits, endian, signed); end
+    def create_read_code(nbits, endian, signed); end
+    def create_read_unpack_code(nbits, endian, signed); end
+    def create_to_binary_s_code(nbits, endian, signed); end
+    def create_uint2int_code(nbits); end
+    def need_signed_conversion_code?(nbits, signed); end
+    def pack_directive(nbits, endian, signed); end
+    def val_as_packed_words(nbits, endian, signed); end
+  end
 end
 
 class BinData::Int32be < ::BinData::BasePrimitive
@@ -678,7 +719,7 @@ class BinData::LazyEvaluator
   def initialize(obj); end
 
   def index; end
-  def lazy_eval(val, overrides = _); end
+  def lazy_eval(val, overrides = T.unsafe(nil)); end
   def method_missing(symbol, *args); end
   def parent; end
 
@@ -705,7 +746,7 @@ class BinData::Primitive < ::BinData::BasePrimitive
   def do_write(io); end
   def initialize_instance; end
   def method_missing(symbol, *args, &block); end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
 
   private
 
@@ -714,7 +755,9 @@ class BinData::Primitive < ::BinData::BasePrimitive
   def sensible_default; end
   def set(v); end
 
-  def self.bit_aligned; end
+  class << self
+    def bit_aligned; end
+  end
 end
 
 class BinData::PrimitiveArgProcessor < ::BinData::BaseArgProcessor
@@ -732,7 +775,9 @@ end
 class BinData::Record < ::BinData::Struct
   extend(::BinData::DSLMixin)
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 class BinData::RecordArgProcessor < ::BinData::StructArgProcessor
@@ -744,7 +789,9 @@ end
 module BinData::RegisterNamePlugin
   def initialize_shared_instance; end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 BinData::RegisteredClasses = T.let(T.unsafe(nil), BinData::Registry)
@@ -752,7 +799,7 @@ BinData::RegisteredClasses = T.let(T.unsafe(nil), BinData::Registry)
 class BinData::Registry
   def initialize; end
 
-  def lookup(name, hints = _); end
+  def lookup(name, hints = T.unsafe(nil)); end
   def register(name, class_to_register); end
   def underscore_name(name); end
   def unregister(name); end
@@ -799,7 +846,7 @@ class BinData::SanitizedField < ::BinData::SanitizedParameter
   def initialize(name, field_type, field_params, hints); end
 
   def has_parameter?(param); end
-  def instantiate(value = _, parent = _); end
+  def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
   def name; end
   def name_as_sym; end
   def prototype; end
@@ -808,7 +855,7 @@ end
 class BinData::SanitizedFields < ::BinData::SanitizedParameter
   include(::Enumerable)
 
-  def initialize(hints, base_fields = _); end
+  def initialize(hints, base_fields = T.unsafe(nil)); end
 
   def [](idx); end
   def add_field(type, name, params); end
@@ -859,7 +906,9 @@ class BinData::SanitizedParameters < ::Hash
   def needs_sanitizing?(key); end
   def sanitize!; end
 
-  def self.sanitize(parameters, the_class); end
+  class << self
+    def sanitize(parameters, the_class); end
+  end
 end
 
 BinData::SanitizedParameters::BIG_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedBigEndian)
@@ -870,7 +919,7 @@ class BinData::SanitizedPrototype < ::BinData::SanitizedParameter
   def initialize(obj_type, obj_params, hints); end
 
   def has_parameter?(param); end
-  def instantiate(value = _, parent = _); end
+  def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
 end
 
 class BinData::Sbit < ::BinData::BasePrimitive
@@ -956,7 +1005,7 @@ class BinData::Stringz < ::BinData::BasePrimitive
   def read_and_return_value(io); end
   def sensible_default; end
   def trim_and_zero_terminate(str); end
-  def trim_to!(str, max_length = _); end
+  def trim_to!(str, max_length = T.unsafe(nil)); end
   def truncate_after_first_zero_byte!(str); end
   def value_to_binary_string(val); end
 end
@@ -972,7 +1021,7 @@ class BinData::Struct < ::BinData::Base
   def do_read(io); end
   def do_write(io); end
   def each_pair; end
-  def field_names(include_hidden = _); end
+  def field_names(include_hidden = T.unsafe(nil)); end
   def has_key?(key); end
   def initialize_instance; end
   def initialize_shared_instance; end
@@ -995,7 +1044,9 @@ class BinData::Struct < ::BinData::Base
   def sum_num_bytes_below_index(index); end
   def sum_num_bytes_for_all_fields; end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 BinData::Struct::RESERVED = T.let(T.unsafe(nil), Hash)
@@ -1003,7 +1054,7 @@ BinData::Struct::RESERVED = T.let(T.unsafe(nil), Hash)
 class BinData::Struct::Snapshot < ::Hash
   def []=(key, value); end
   def method_missing(symbol, *args); end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
 end
 
 class BinData::StructArgProcessor < ::BinData::BaseArgProcessor
diff --git a/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi
index f0a3c279f3..76f1693fdc 100644
--- a/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi
@@ -1,15 +1,18 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `byebug` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Byebug
-  def self.attach; end
-  def self.spawn(host = _, port = _); end
+  class << self
+    def attach; end
+    def spawn(host = T.unsafe(nil), port = T.unsafe(nil)); end
+  end
 end
 
 module Kernel
   def byebug; end
   def debugger; end
-  def remote_byebug(host = _, port = _); end
+  def remote_byebug(host = T.unsafe(nil), port = T.unsafe(nil)); end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/codecov@0.2.3.rbi b/Library/Homebrew/sorbet/rbi/gems/codecov@0.2.5.rbi
similarity index 58%
rename from Library/Homebrew/sorbet/rbi/gems/codecov@0.2.3.rbi
rename to Library/Homebrew/sorbet/rbi/gems/codecov@0.2.5.rbi
index 5ace243e13..e33729f223 100644
--- a/Library/Homebrew/sorbet/rbi/gems/codecov@0.2.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/codecov@0.2.5.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `codecov` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi
index 27b1fb4bc6..e4f321bd91 100644
--- a/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `coderay` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/colorize@0.8.1.rbi b/Library/Homebrew/sorbet/rbi/gems/colorize@0.8.1.rbi
index 198c6b42fc..9bc5e047e1 100644
--- a/Library/Homebrew/sorbet/rbi/gems/colorize@0.8.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/colorize@0.8.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `colorize` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/commander@4.5.2.rbi b/Library/Homebrew/sorbet/rbi/gems/commander@4.5.2.rbi
index bfbd3dd171..c5c7b6135a 100644
--- a/Library/Homebrew/sorbet/rbi/gems/commander@4.5.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/commander@4.5.2.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `commander` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.6.rbi b/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.6.rbi
index abba436190..179aa4844a 100644
--- a/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.6.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.6.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `concurrent-ruby` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -23,40 +24,42 @@ module Concurrent
   def leave_transaction; end
   def monotonic_time; end
 
-  def self.abort_transaction; end
-  def self.atomically; end
-  def self.call_dataflow(method, executor, *inputs, &block); end
-  def self.create_simple_logger(level = _, output = _); end
-  def self.create_stdlib_logger(level = _, output = _); end
-  def self.dataflow(*inputs, &block); end
-  def self.dataflow!(*inputs, &block); end
-  def self.dataflow_with(executor, *inputs, &block); end
-  def self.dataflow_with!(executor, *inputs, &block); end
-  def self.disable_at_exit_handlers!; end
-  def self.executor(executor_identifier); end
-  def self.global_fast_executor; end
-  def self.global_immediate_executor; end
-  def self.global_io_executor; end
-  def self.global_logger; end
-  def self.global_logger=(value); end
-  def self.global_timer_set; end
-  def self.leave_transaction; end
-  def self.monotonic_time; end
-  def self.new_fast_executor(opts = _); end
-  def self.new_io_executor(opts = _); end
-  def self.physical_processor_count; end
-  def self.processor_count; end
-  def self.processor_counter; end
-  def self.use_simple_logger(level = _, output = _); end
-  def self.use_stdlib_logger(level = _, output = _); end
+  class << self
+    def abort_transaction; end
+    def atomically; end
+    def call_dataflow(method, executor, *inputs, &block); end
+    def create_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+    def create_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+    def dataflow(*inputs, &block); end
+    def dataflow!(*inputs, &block); end
+    def dataflow_with(executor, *inputs, &block); end
+    def dataflow_with!(executor, *inputs, &block); end
+    def disable_at_exit_handlers!; end
+    def executor(executor_identifier); end
+    def global_fast_executor; end
+    def global_immediate_executor; end
+    def global_io_executor; end
+    def global_logger; end
+    def global_logger=(value); end
+    def global_timer_set; end
+    def leave_transaction; end
+    def monotonic_time; end
+    def new_fast_executor(opts = T.unsafe(nil)); end
+    def new_io_executor(opts = T.unsafe(nil)); end
+    def physical_processor_count; end
+    def processor_count; end
+    def processor_counter; end
+    def use_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+    def use_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+  end
 end
 
 class Concurrent::AbstractExchanger < ::Concurrent::Synchronization::Object
   def initialize; end
 
-  def exchange(value, timeout = _); end
-  def exchange!(value, timeout = _); end
-  def try_exchange(value, timeout = _); end
+  def exchange(value, timeout = T.unsafe(nil)); end
+  def exchange!(value, timeout = T.unsafe(nil)); end
+  def try_exchange(value, timeout = T.unsafe(nil)); end
 
   private
 
@@ -69,7 +72,7 @@ class Concurrent::AbstractExecutorService < ::Concurrent::Synchronization::Locka
   include(::Concurrent::ExecutorService)
   include(::Concurrent::Concern::Deprecation)
 
-  def initialize(opts = _, &block); end
+  def initialize(opts = T.unsafe(nil), &block); end
 
   def auto_terminate=(value); end
   def auto_terminate?; end
@@ -81,7 +84,7 @@ class Concurrent::AbstractExecutorService < ::Concurrent::Synchronization::Locka
   def shutdown?; end
   def shuttingdown?; end
   def to_s; end
-  def wait_for_termination(timeout = _); end
+  def wait_for_termination(timeout = T.unsafe(nil)); end
 
   private
 
@@ -95,7 +98,7 @@ end
 Concurrent::AbstractExecutorService::FALLBACK_POLICIES = T.let(T.unsafe(nil), Array)
 
 class Concurrent::AbstractThreadLocalVar
-  def initialize(default = _, &default_block); end
+  def initialize(default = T.unsafe(nil), &default_block); end
 
   def bind(value, &block); end
   def value; end
@@ -110,7 +113,7 @@ end
 class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject
   include(::Concurrent::Concern::Observable)
 
-  def initialize(initial, opts = _); end
+  def initialize(initial, opts = T.unsafe(nil)); end
 
   def <<(action); end
   def await; end
@@ -122,7 +125,7 @@ class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject
   def failed?; end
   def post(*args, &action); end
   def reason; end
-  def restart(new_value, opts = _); end
+  def restart(new_value, opts = T.unsafe(nil)); end
   def send(*args, &action); end
   def send!(*args, &action); end
   def send_off(*args, &action); end
@@ -131,7 +134,7 @@ class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject
   def send_via!(executor, *args, &action); end
   def stopped?; end
   def value; end
-  def wait(timeout = _); end
+  def wait(timeout = T.unsafe(nil)); end
 
   private
 
@@ -139,23 +142,25 @@ class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject
   def enqueue_await_job(latch); end
   def execute_next_job; end
   def handle_error(error); end
-  def ns_enqueue_job(job, index = _); end
+  def ns_enqueue_job(job, index = T.unsafe(nil)); end
   def ns_find_last_job_for_thread; end
   def ns_initialize(initial, opts); end
   def ns_post_next_job; end
   def ns_validate(value); end
 
-  def self.await(*agents); end
-  def self.await_for(timeout, *agents); end
-  def self.await_for!(timeout, *agents); end
+  class << self
+    def await(*agents); end
+    def await_for(timeout, *agents); end
+    def await_for!(timeout, *agents); end
+  end
 end
 
 class Concurrent::Agent::Error < ::StandardError
-  def initialize(message = _); end
+  def initialize(message = T.unsafe(nil)); end
 end
 
 class Concurrent::Agent::ValidationError < ::Concurrent::Agent::Error
-  def initialize(message = _); end
+  def initialize(message = T.unsafe(nil)); end
 end
 
 class Concurrent::Array < ::Array
@@ -168,14 +173,16 @@ module Concurrent::Async
   def cast; end
   def init_synchronization; end
 
-  def self.included(base); end
-  def self.validate_argc(obj, method, *args); end
+  class << self
+    def included(base); end
+    def validate_argc(obj, method, *args); end
+  end
 end
 
 class Concurrent::Atom < ::Concurrent::Synchronization::Object
   include(::Concurrent::Concern::Observable)
 
-  def initialize(value, opts = _); end
+  def initialize(value, opts = T.unsafe(nil)); end
 
   def __initialize_atomic_fields__; end
   def compare_and_set(old_value, new_value); end
@@ -192,7 +199,9 @@ class Concurrent::Atom < ::Concurrent::Synchronization::Object
   def valid?(new_value); end
   def value=(value); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 class Concurrent::AtomicBoolean < ::Concurrent::MutexAtomicBoolean
@@ -212,7 +221,7 @@ class Concurrent::AtomicFixnum < ::Concurrent::MutexAtomicFixnum
 end
 
 class Concurrent::AtomicMarkableReference < ::Concurrent::Synchronization::Object
-  def initialize(value = _, mark = _); end
+  def initialize(value = T.unsafe(nil), mark = T.unsafe(nil)); end
 
   def __initialize_atomic_fields__; end
   def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
@@ -235,7 +244,9 @@ class Concurrent::AtomicMarkableReference < ::Concurrent::Synchronization::Objec
   def swap_reference(value); end
   def update_reference(&block); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 module Concurrent::AtomicNumericCompareAndSetWrapper
@@ -248,7 +259,7 @@ class Concurrent::AtomicReference < ::Concurrent::MutexAtomicReference
 end
 
 class Concurrent::CachedThreadPool < ::Concurrent::ThreadPoolExecutor
-  def initialize(opts = _); end
+  def initialize(opts = T.unsafe(nil)); end
 
 
   private
@@ -265,7 +276,7 @@ end
 class Concurrent::Collection::CopyOnNotifyObserverSet < ::Concurrent::Synchronization::LockableObject
   def initialize; end
 
-  def add_observer(observer = _, func = _, &block); end
+  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
   def count_observers; end
   def delete_observer(observer); end
   def delete_observers; end
@@ -286,7 +297,7 @@ end
 class Concurrent::Collection::CopyOnWriteObserverSet < ::Concurrent::Synchronization::LockableObject
   def initialize; end
 
-  def add_observer(observer = _, func = _, &block); end
+  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
   def count_observers; end
   def delete_observer(observer); end
   def delete_observers; end
@@ -308,7 +319,7 @@ end
 Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend
 
 class Concurrent::Collection::MriMapBackend < ::Concurrent::Collection::NonConcurrentMapBackend
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def []=(key, value); end
   def clear; end
@@ -324,7 +335,7 @@ class Concurrent::Collection::MriMapBackend < ::Concurrent::Collection::NonConcu
 end
 
 class Concurrent::Collection::NonConcurrentMapBackend
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def [](key); end
   def []=(key, value); end
@@ -363,7 +374,7 @@ class Concurrent::Collection::NonConcurrentPriorityQueue < ::Concurrent::Collect
 end
 
 class Concurrent::Collection::RubyNonConcurrentPriorityQueue
-  def initialize(opts = _); end
+  def initialize(opts = T.unsafe(nil)); end
 
   def <<(item); end
   def clear; end
@@ -387,7 +398,9 @@ class Concurrent::Collection::RubyNonConcurrentPriorityQueue
   def swap(x, y); end
   def swim(k); end
 
-  def self.from_list(list, opts = _); end
+  class << self
+    def from_list(list, opts = T.unsafe(nil)); end
+  end
 end
 
 module Concurrent::Concern
@@ -400,7 +413,7 @@ module Concurrent::Concern::Deprecation
   extend(::Concurrent::Concern::Logging)
   extend(::Concurrent::Concern::Deprecation)
 
-  def deprecated(message, strip = _); end
+  def deprecated(message, strip = T.unsafe(nil)); end
   def deprecated_method(old_name, new_name); end
 end
 
@@ -412,14 +425,14 @@ module Concurrent::Concern::Dereferenceable
 
   def apply_deref_options(value); end
   def ns_set_deref_options(opts); end
-  def set_deref_options(opts = _); end
+  def set_deref_options(opts = T.unsafe(nil)); end
   def value=(value); end
 end
 
 module Concurrent::Concern::Logging
   include(::Logger::Severity)
 
-  def log(level, progname, message = _, &block); end
+  def log(level, progname, message = T.unsafe(nil), &block); end
 end
 
 module Concurrent::Concern::Obligation
@@ -429,23 +442,23 @@ module Concurrent::Concern::Obligation
   def exception(*args); end
   def fulfilled?; end
   def incomplete?; end
-  def no_error!(timeout = _); end
+  def no_error!(timeout = T.unsafe(nil)); end
   def pending?; end
   def realized?; end
   def reason; end
   def rejected?; end
   def state; end
   def unscheduled?; end
-  def value(timeout = _); end
-  def value!(timeout = _); end
-  def wait(timeout = _); end
-  def wait!(timeout = _); end
+  def value(timeout = T.unsafe(nil)); end
+  def value!(timeout = T.unsafe(nil)); end
+  def wait(timeout = T.unsafe(nil)); end
+  def wait!(timeout = T.unsafe(nil)); end
 
   protected
 
   def compare_and_set_state(next_state, *expected_current); end
   def event; end
-  def get_arguments_from(opts = _); end
+  def get_arguments_from(opts = T.unsafe(nil)); end
   def if_state(*expected_states); end
   def init_obligation; end
   def ns_check_state?(expected); end
@@ -455,11 +468,11 @@ module Concurrent::Concern::Obligation
 end
 
 module Concurrent::Concern::Observable
-  def add_observer(observer = _, func = _, &block); end
+  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
   def count_observers; end
   def delete_observer(observer); end
   def delete_observers; end
-  def with_observer(observer = _, func = _, &block); end
+  def with_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
 
   protected
 
@@ -485,11 +498,11 @@ class Concurrent::CyclicBarrier < ::Concurrent::Synchronization::LockableObject
   def number_waiting; end
   def parties; end
   def reset; end
-  def wait(timeout = _); end
+  def wait(timeout = T.unsafe(nil)); end
 
   protected
 
-  def ns_generation_done(generation, status, continue = _); end
+  def ns_generation_done(generation, status, continue = T.unsafe(nil)); end
   def ns_initialize(parties, &block); end
   def ns_next_generation; end
 end
@@ -498,12 +511,12 @@ class Concurrent::Delay < ::Concurrent::Synchronization::LockableObject
   include(::Concurrent::Concern::Dereferenceable)
   include(::Concurrent::Concern::Obligation)
 
-  def initialize(opts = _, &block); end
+  def initialize(opts = T.unsafe(nil), &block); end
 
   def reconfigure(&block); end
-  def value(timeout = _); end
-  def value!(timeout = _); end
-  def wait(timeout = _); end
+  def value(timeout = T.unsafe(nil)); end
+  def value!(timeout = T.unsafe(nil)); end
+  def wait(timeout = T.unsafe(nil)); end
 
   protected
 
@@ -530,7 +543,7 @@ class Concurrent::Event < ::Concurrent::Synchronization::LockableObject
   def set; end
   def set?; end
   def try?; end
-  def wait(timeout = _); end
+  def wait(timeout = T.unsafe(nil)); end
 
   protected
 
@@ -552,23 +565,25 @@ module Concurrent::ExecutorService
 end
 
 class Concurrent::FixedThreadPool < ::Concurrent::ThreadPoolExecutor
-  def initialize(num_threads, opts = _); end
+  def initialize(num_threads, opts = T.unsafe(nil)); end
 end
 
 class Concurrent::Future < ::Concurrent::IVar
-  def initialize(opts = _, &block); end
+  def initialize(opts = T.unsafe(nil), &block); end
 
   def cancel; end
   def cancelled?; end
   def execute; end
-  def set(value = _, &block); end
+  def set(value = T.unsafe(nil), &block); end
   def wait_or_cancel(timeout); end
 
   protected
 
   def ns_initialize(value, opts); end
 
-  def self.execute(opts = _, &block); end
+  class << self
+    def execute(opts = T.unsafe(nil), &block); end
+  end
 end
 
 class Concurrent::Hash < ::Hash
@@ -579,12 +594,12 @@ class Concurrent::IVar < ::Concurrent::Synchronization::LockableObject
   include(::Concurrent::Concern::Obligation)
   include(::Concurrent::Concern::Observable)
 
-  def initialize(value = _, opts = _, &block); end
+  def initialize(value = T.unsafe(nil), opts = T.unsafe(nil), &block); end
 
-  def add_observer(observer = _, func = _, &block); end
-  def fail(reason = _); end
-  def set(value = _); end
-  def try_set(value = _, &block); end
+  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
+  def fail(reason = T.unsafe(nil)); end
+  def set(value = T.unsafe(nil)); end
+  def try_set(value = T.unsafe(nil), &block); end
 
   protected
 
@@ -594,7 +609,7 @@ class Concurrent::IVar < ::Concurrent::Synchronization::LockableObject
   def notify_observers(value, reason); end
   def ns_complete_without_notification(success, value, reason); end
   def ns_initialize(value, opts); end
-  def safe_execute(task, args = _); end
+  def safe_execute(task, args = T.unsafe(nil)); end
 end
 
 class Concurrent::IllegalOperationError < ::Concurrent::Error
@@ -612,7 +627,7 @@ class Concurrent::ImmediateExecutor < ::Concurrent::AbstractExecutorService
   def shutdown; end
   def shutdown?; end
   def shuttingdown?; end
-  def wait_for_termination(timeout = _); end
+  def wait_for_termination(timeout = T.unsafe(nil)); end
 end
 
 class Concurrent::ImmutabilityError < ::Concurrent::Error
@@ -638,8 +653,10 @@ module Concurrent::ImmutableStruct
 
   def initialize_copy(original); end
 
-  def self.included(base); end
-  def self.new(*args, &block); end
+  class << self
+    def included(base); end
+    def new(*args, &block); end
+  end
 end
 
 class Concurrent::IndirectImmediateExecutor < ::Concurrent::ImmediateExecutor
@@ -657,7 +674,7 @@ end
 class Concurrent::LockFreeStack < ::Concurrent::Synchronization::Object
   include(::Enumerable)
 
-  def initialize(head = _); end
+  def initialize(head = T.unsafe(nil)); end
 
   def __initialize_atomic_fields__; end
   def clear; end
@@ -666,8 +683,8 @@ class Concurrent::LockFreeStack < ::Concurrent::Synchronization::Object
   def compare_and_clear(head); end
   def compare_and_pop(head); end
   def compare_and_push(head, value); end
-  def each(head = _); end
-  def empty?(head = _); end
+  def each(head = T.unsafe(nil)); end
+  def empty?(head = T.unsafe(nil)); end
   def inspect; end
   def peek; end
   def pop; end
@@ -683,9 +700,11 @@ class Concurrent::LockFreeStack < ::Concurrent::Synchronization::Object
   def swap_head(value); end
   def update_head(&block); end
 
-  def self.new(*args, &block); end
-  def self.of1(value); end
-  def self.of2(value1, value2); end
+  class << self
+    def new(*args, &block); end
+    def of1(value); end
+    def of2(value1, value2); end
+  end
 end
 
 Concurrent::LockFreeStack::EMPTY = T.let(T.unsafe(nil), Concurrent::LockFreeStack::Node)
@@ -697,22 +716,24 @@ class Concurrent::LockFreeStack::Node
   def value; end
   def value=(_); end
 
-  def self.[](*_); end
+  class << self
+    def [](*_); end
+  end
 end
 
 class Concurrent::MVar < ::Concurrent::Synchronization::Object
   include(::Concurrent::Concern::Dereferenceable)
 
-  def initialize(value = _, opts = _); end
+  def initialize(value = T.unsafe(nil), opts = T.unsafe(nil)); end
 
-  def borrow(timeout = _); end
+  def borrow(timeout = T.unsafe(nil)); end
   def empty?; end
   def full?; end
-  def modify(timeout = _); end
+  def modify(timeout = T.unsafe(nil)); end
   def modify!; end
-  def put(value, timeout = _); end
+  def put(value, timeout = T.unsafe(nil)); end
   def set!(value); end
-  def take(timeout = _); end
+  def take(timeout = T.unsafe(nil)); end
   def try_put!(value); end
   def try_take!; end
 
@@ -728,7 +749,9 @@ class Concurrent::MVar < ::Concurrent::Synchronization::Object
   def wait_for_full(timeout); end
   def wait_while(condition, timeout); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 Concurrent::MVar::EMPTY = T.let(T.unsafe(nil), Object)
@@ -736,7 +759,7 @@ Concurrent::MVar::EMPTY = T.let(T.unsafe(nil), Object)
 Concurrent::MVar::TIMEOUT = T.let(T.unsafe(nil), Object)
 
 class Concurrent::Map < ::Concurrent::Collection::MriMapBackend
-  def initialize(options = _, &block); end
+  def initialize(options = T.unsafe(nil), &block); end
 
   def [](key); end
   def each; end
@@ -744,8 +767,8 @@ class Concurrent::Map < ::Concurrent::Collection::MriMapBackend
   def each_pair; end
   def each_value; end
   def empty?; end
-  def fetch(key, default_value = _); end
-  def fetch_or_store(key, default_value = _); end
+  def fetch(key, default_value = T.unsafe(nil)); end
+  def fetch_or_store(key, default_value = T.unsafe(nil)); end
   def get(key); end
   def inspect; end
   def key(value); end
@@ -784,22 +807,28 @@ class Concurrent::Maybe < ::Concurrent::Synchronization::Object
   def rejected?; end
   def value; end
 
-  def self.from(*args); end
-  def self.just(value); end
-  def self.nothing(error = _); end
+  class << self
+    def from(*args); end
+    def just(value); end
+    def nothing(error = T.unsafe(nil)); end
+
+    private
+
+    def new(*args, &block); end
+  end
 end
 
 Concurrent::Maybe::NONE = T.let(T.unsafe(nil), Object)
 
 class Concurrent::MultipleAssignmentError < ::Concurrent::Error
-  def initialize(message = _, inspection_data = _); end
+  def initialize(message = T.unsafe(nil), inspection_data = T.unsafe(nil)); end
 
   def inspect; end
   def inspection_data; end
 end
 
 class Concurrent::MultipleErrors < ::Concurrent::Error
-  def initialize(errors, message = _); end
+  def initialize(errors, message = T.unsafe(nil)); end
 
   def errors; end
 end
@@ -825,11 +854,13 @@ module Concurrent::MutableStruct
 
   def initialize_copy(original); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 class Concurrent::MutexAtomicBoolean < ::Concurrent::Synchronization::LockableObject
-  def initialize(initial = _); end
+  def initialize(initial = T.unsafe(nil)); end
 
   def false?; end
   def make_false; end
@@ -848,13 +879,13 @@ class Concurrent::MutexAtomicBoolean < ::Concurrent::Synchronization::LockableOb
 end
 
 class Concurrent::MutexAtomicFixnum < ::Concurrent::Synchronization::LockableObject
-  def initialize(initial = _); end
+  def initialize(initial = T.unsafe(nil)); end
 
   def compare_and_set(expect, update); end
-  def decrement(delta = _); end
-  def down(delta = _); end
-  def increment(delta = _); end
-  def up(delta = _); end
+  def decrement(delta = T.unsafe(nil)); end
+  def down(delta = T.unsafe(nil)); end
+  def increment(delta = T.unsafe(nil)); end
+  def up(delta = T.unsafe(nil)); end
   def update; end
   def value; end
   def value=(value); end
@@ -872,7 +903,7 @@ class Concurrent::MutexAtomicReference < ::Concurrent::Synchronization::Lockable
   include(::Concurrent::AtomicDirectUpdate)
   include(::Concurrent::AtomicNumericCompareAndSetWrapper)
 
-  def initialize(value = _); end
+  def initialize(value = T.unsafe(nil)); end
 
   def _compare_and_set(old_value, new_value); end
   def compare_and_swap(old_value, new_value); end
@@ -889,11 +920,11 @@ class Concurrent::MutexAtomicReference < ::Concurrent::Synchronization::Lockable
 end
 
 class Concurrent::MutexCountDownLatch < ::Concurrent::Synchronization::LockableObject
-  def initialize(count = _); end
+  def initialize(count = T.unsafe(nil)); end
 
   def count; end
   def count_down; end
-  def wait(timeout = _); end
+  def wait(timeout = T.unsafe(nil)); end
 
   protected
 
@@ -903,12 +934,12 @@ end
 class Concurrent::MutexSemaphore < ::Concurrent::Synchronization::LockableObject
   def initialize(count); end
 
-  def acquire(permits = _); end
+  def acquire(permits = T.unsafe(nil)); end
   def available_permits; end
   def drain_permits; end
   def reduce_permits(reduction); end
-  def release(permits = _); end
-  def try_acquire(permits = _, timeout = _); end
+  def release(permits = T.unsafe(nil)); end
+  def try_acquire(permits = T.unsafe(nil), timeout = T.unsafe(nil)); end
 
   protected
 
@@ -925,21 +956,23 @@ Concurrent::NULL = T.let(T.unsafe(nil), Object)
 Concurrent::NULL_LOGGER = T.let(T.unsafe(nil), Proc)
 
 module Concurrent::Options
-  def self.executor(executor_identifier); end
-  def self.executor_from_options(opts = _); end
+  class << self
+    def executor(executor_identifier); end
+    def executor_from_options(opts = T.unsafe(nil)); end
+  end
 end
 
 class Concurrent::Promise < ::Concurrent::IVar
-  def initialize(opts = _, &block); end
+  def initialize(opts = T.unsafe(nil), &block); end
 
   def catch(&block); end
   def execute; end
-  def fail(reason = _); end
+  def fail(reason = T.unsafe(nil)); end
   def flat_map(&block); end
   def on_error(&block); end
   def on_success(&block); end
   def rescue(&block); end
-  def set(value = _, &block); end
+  def set(value = T.unsafe(nil), &block); end
   def then(*args, &block); end
   def zip(*others); end
 
@@ -956,13 +989,15 @@ class Concurrent::Promise < ::Concurrent::IVar
   def set_state!(success, value, reason); end
   def synchronized_set_state!(success, value, reason); end
 
-  def self.aggregate(method, *promises); end
-  def self.all?(*promises); end
-  def self.any?(*promises); end
-  def self.execute(opts = _, &block); end
-  def self.fulfill(value, opts = _); end
-  def self.reject(reason, opts = _); end
-  def self.zip(*promises); end
+  class << self
+    def aggregate(method, *promises); end
+    def all?(*promises); end
+    def any?(*promises); end
+    def execute(opts = T.unsafe(nil), &block); end
+    def fulfill(value, opts = T.unsafe(nil)); end
+    def reject(reason, opts = T.unsafe(nil)); end
+    def zip(*promises); end
+  end
 end
 
 class Concurrent::PromiseExecutionError < ::StandardError
@@ -992,14 +1027,14 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
   def on_resolution_using(executor, *args, &callback); end
   def pending?; end
   def promise; end
-  def resolve_with(state, raise_on_reassign = _, reserved = _); end
+  def resolve_with(state, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
   def resolved?; end
   def state; end
   def tangle(resolvable); end
   def to_s; end
   def touch; end
   def touched?; end
-  def wait(timeout = _); end
+  def wait(timeout = T.unsafe(nil)); end
   def waiting_threads; end
   def with_default_executor(executor); end
   def with_hidden_resolvable; end
@@ -1019,7 +1054,9 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
   def wait_until_resolved(timeout); end
   def with_async(executor, *args, &block); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
@@ -1055,17 +1092,17 @@ module Concurrent::Promises::FactoryMethods
   def any_resolved_future_on(default_executor, *futures_and_or_events); end
   def delay(*args, &task); end
   def delay_on(default_executor, *args, &task); end
-  def fulfilled_future(value, default_executor = _); end
+  def fulfilled_future(value, default_executor = T.unsafe(nil)); end
   def future(*args, &task); end
   def future_on(default_executor, *args, &task); end
-  def make_future(argument = _, default_executor = _); end
-  def rejected_future(reason, default_executor = _); end
+  def make_future(argument = T.unsafe(nil), default_executor = T.unsafe(nil)); end
+  def rejected_future(reason, default_executor = T.unsafe(nil)); end
   def resolvable_event; end
-  def resolvable_event_on(default_executor = _); end
+  def resolvable_event_on(default_executor = T.unsafe(nil)); end
   def resolvable_future; end
-  def resolvable_future_on(default_executor = _); end
-  def resolved_event(default_executor = _); end
-  def resolved_future(fulfilled, value, reason, default_executor = _); end
+  def resolvable_future_on(default_executor = T.unsafe(nil)); end
+  def resolved_event(default_executor = T.unsafe(nil)); end
+  def resolved_future(fulfilled, value, reason, default_executor = T.unsafe(nil)); end
   def schedule(intended_time, *args, &task); end
   def schedule_on(default_executor, intended_time, *args, &task); end
   def zip(*futures_and_or_events); end
@@ -1085,9 +1122,9 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
   def apply(args, block); end
   def delay; end
   def exception(*args); end
-  def flat(level = _); end
+  def flat(level = T.unsafe(nil)); end
   def flat_event; end
-  def flat_future(level = _); end
+  def flat_future(level = T.unsafe(nil)); end
   def fulfilled?; end
   def inspect; end
   def on_fulfillment(*args, &callback); end
@@ -1096,21 +1133,21 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
   def on_rejection(*args, &callback); end
   def on_rejection!(*args, &callback); end
   def on_rejection_using(executor, *args, &callback); end
-  def reason(timeout = _, timeout_value = _); end
+  def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
   def rejected?; end
   def rescue(*args, &task); end
   def rescue_on(executor, *args, &task); end
-  def result(timeout = _); end
-  def run(run_test = _); end
+  def result(timeout = T.unsafe(nil)); end
+  def run(run_test = T.unsafe(nil)); end
   def schedule(intended_time); end
   def then(*args, &task); end
   def then_on(executor, *args, &task); end
   def to_event; end
   def to_future; end
   def to_s; end
-  def value(timeout = _, timeout_value = _); end
-  def value!(timeout = _, timeout_value = _); end
-  def wait!(timeout = _); end
+  def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
+  def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
+  def wait!(timeout = T.unsafe(nil)); end
   def with_default_executor(executor); end
   def zip(other); end
   def |(event_or_future); end
@@ -1124,7 +1161,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
   def callback_on_resolution(state, args, callback); end
   def rejected_resolution(raise_on_reassign, state); end
   def run_test(v); end
-  def wait_until_resolved!(timeout = _); end
+  def wait_until_resolved!(timeout = T.unsafe(nil)); end
 end
 
 module Concurrent::Promises::Resolvable
@@ -1133,8 +1170,8 @@ end
 class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event
   include(::Concurrent::Promises::Resolvable)
 
-  def resolve(raise_on_reassign = _, reserved = _); end
-  def wait(timeout = _, resolve_on_timeout = _); end
+  def resolve(raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
+  def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
   def with_hidden_resolvable; end
 end
 
@@ -1143,15 +1180,15 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
 
   def evaluate_to(*args, &block); end
   def evaluate_to!(*args, &block); end
-  def fulfill(value, raise_on_reassign = _, reserved = _); end
-  def reason(timeout = _, timeout_value = _, resolve_on_timeout = _); end
-  def reject(reason, raise_on_reassign = _, reserved = _); end
-  def resolve(fulfilled = _, value = _, reason = _, raise_on_reassign = _, reserved = _); end
-  def result(timeout = _, resolve_on_timeout = _); end
-  def value(timeout = _, timeout_value = _, resolve_on_timeout = _); end
-  def value!(timeout = _, timeout_value = _, resolve_on_timeout = _); end
-  def wait(timeout = _, resolve_on_timeout = _); end
-  def wait!(timeout = _, resolve_on_timeout = _); end
+  def fulfill(value, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
+  def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+  def reject(reason, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
+  def resolve(fulfilled = T.unsafe(nil), value = T.unsafe(nil), reason = T.unsafe(nil), raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
+  def result(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+  def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+  def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+  def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+  def wait!(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
   def with_hidden_resolvable; end
 end
 
@@ -1175,15 +1212,17 @@ class Concurrent::ReadWriteLock < ::Concurrent::Synchronization::Object
 
   private
 
-  def max_readers?(c = _); end
-  def max_writers?(c = _); end
-  def running_readers(c = _); end
-  def running_readers?(c = _); end
-  def running_writer?(c = _); end
-  def waiting_writer?(c = _); end
-  def waiting_writers(c = _); end
+  def max_readers?(c = T.unsafe(nil)); end
+  def max_writers?(c = T.unsafe(nil)); end
+  def running_readers(c = T.unsafe(nil)); end
+  def running_readers?(c = T.unsafe(nil)); end
+  def running_writer?(c = T.unsafe(nil)); end
+  def waiting_writer?(c = T.unsafe(nil)); end
+  def waiting_writers(c = T.unsafe(nil)); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 Concurrent::ReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
@@ -1208,15 +1247,17 @@ class Concurrent::ReentrantReadWriteLock < ::Concurrent::Synchronization::Object
 
   private
 
-  def max_readers?(c = _); end
-  def max_writers?(c = _); end
-  def running_readers(c = _); end
-  def running_readers?(c = _); end
-  def running_writer?(c = _); end
-  def waiting_or_running_writer?(c = _); end
-  def waiting_writers(c = _); end
+  def max_readers?(c = T.unsafe(nil)); end
+  def max_writers?(c = T.unsafe(nil)); end
+  def running_readers(c = T.unsafe(nil)); end
+  def running_readers?(c = T.unsafe(nil)); end
+  def running_writer?(c = T.unsafe(nil)); end
+  def waiting_or_running_writer?(c = T.unsafe(nil)); end
+  def waiting_writers(c = T.unsafe(nil)); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 Concurrent::ReentrantReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
@@ -1257,7 +1298,9 @@ class Concurrent::RubyExchanger < ::Concurrent::AbstractExchanger
 
   def do_exchange(value, timeout); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 class Concurrent::RubyExecutorService < ::Concurrent::AbstractExecutorService
@@ -1266,7 +1309,7 @@ class Concurrent::RubyExecutorService < ::Concurrent::AbstractExecutorService
   def kill; end
   def post(*args, &task); end
   def shutdown; end
-  def wait_for_termination(timeout = _); end
+  def wait_for_termination(timeout = T.unsafe(nil)); end
 
   private
 
@@ -1279,7 +1322,7 @@ class Concurrent::RubyExecutorService < ::Concurrent::AbstractExecutorService
 end
 
 class Concurrent::RubySingleThreadExecutor < ::Concurrent::RubyThreadPoolExecutor
-  def initialize(opts = _); end
+  def initialize(opts = T.unsafe(nil)); end
 end
 
 class Concurrent::RubyThreadLocalVar < ::Concurrent::AbstractThreadLocalVar
@@ -1293,16 +1336,18 @@ class Concurrent::RubyThreadLocalVar < ::Concurrent::AbstractThreadLocalVar
   private
 
   def get_default; end
-  def get_threadlocal_array(thread = _); end
-  def set_threadlocal_array(array, thread = _); end
+  def get_threadlocal_array(thread = T.unsafe(nil)); end
+  def set_threadlocal_array(array, thread = T.unsafe(nil)); end
   def value_for(thread); end
 
-  def self.thread_finalizer(id); end
-  def self.thread_local_finalizer(index); end
+  class << self
+    def thread_finalizer(id); end
+    def thread_local_finalizer(index); end
+  end
 end
 
 class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
-  def initialize(opts = _); end
+  def initialize(opts = T.unsafe(nil)); end
 
   def can_overflow?; end
   def completed_task_count; end
@@ -1331,7 +1376,7 @@ class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
   def ns_kill_execution; end
   def ns_limited_queue?; end
   def ns_prune_pool; end
-  def ns_ready_worker(worker, success = _); end
+  def ns_ready_worker(worker, success = T.unsafe(nil)); end
   def ns_remove_busy_worker(worker); end
   def ns_reset_if_forked; end
   def ns_shutdown_execution; end
@@ -1348,7 +1393,7 @@ Concurrent::RubyThreadPoolExecutor::DEFAULT_MIN_POOL_SIZE = T.let(T.unsafe(nil),
 Concurrent::RubyThreadPoolExecutor::DEFAULT_THREAD_IDLETIMEOUT = T.let(T.unsafe(nil), Integer)
 
 class Concurrent::SafeTaskExecutor < ::Concurrent::Synchronization::LockableObject
-  def initialize(task, opts = _); end
+  def initialize(task, opts = T.unsafe(nil)); end
 
   def execute(*args); end
 end
@@ -1356,7 +1401,7 @@ end
 class Concurrent::ScheduledTask < ::Concurrent::IVar
   include(::Comparable)
 
-  def initialize(delay, opts = _, &task); end
+  def initialize(delay, opts = T.unsafe(nil), &task); end
 
   def <=>(other); end
   def cancel; end
@@ -1375,7 +1420,9 @@ class Concurrent::ScheduledTask < ::Concurrent::IVar
   def ns_reschedule(delay); end
   def ns_schedule(delay); end
 
-  def self.execute(delay, opts = _, &task); end
+  class << self
+    def execute(delay, opts = T.unsafe(nil), &task); end
+  end
 end
 
 class Concurrent::Semaphore < ::Concurrent::MutexSemaphore
@@ -1414,10 +1461,12 @@ class Concurrent::SerializedExecution::Job < ::Struct
   def executor; end
   def executor=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class Concurrent::SerializedExecutionDelegator < ::SimpleDelegator
@@ -1455,7 +1504,9 @@ module Concurrent::SettableStruct
 
   def initialize_copy(original); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 class Concurrent::SimpleExecutorService < ::Concurrent::RubyExecutorService
@@ -1466,14 +1517,16 @@ class Concurrent::SimpleExecutorService < ::Concurrent::RubyExecutorService
   def shutdown; end
   def shutdown?; end
   def shuttingdown?; end
-  def wait_for_termination(timeout = _); end
+  def wait_for_termination(timeout = T.unsafe(nil)); end
 
   private
 
   def ns_initialize(*args); end
 
-  def self.<<(task); end
-  def self.post(*args); end
+  class << self
+    def <<(task); end
+    def post(*args); end
+  end
 end
 
 class Concurrent::SingleThreadExecutor < ::Concurrent::RubySingleThreadExecutor
@@ -1488,8 +1541,8 @@ class Concurrent::Synchronization::AbstractLockableObject < ::Concurrent::Synchr
 
   def ns_broadcast; end
   def ns_signal; end
-  def ns_wait(timeout = _); end
-  def ns_wait_until(timeout = _, &condition); end
+  def ns_wait(timeout = T.unsafe(nil)); end
+  def ns_wait_until(timeout = T.unsafe(nil), &condition); end
   def synchronize; end
 end
 
@@ -1498,7 +1551,9 @@ class Concurrent::Synchronization::AbstractObject
 
   def full_memory_barrier; end
 
-  def self.attr_volatile(*names); end
+  class << self
+    def attr_volatile(*names); end
+  end
 end
 
 module Concurrent::Synchronization::AbstractStruct
@@ -1523,7 +1578,9 @@ module Concurrent::Synchronization::AbstractStruct
   def ns_values_at(indexes); end
   def pr_underscore(clazz); end
 
-  def self.define_struct_class(parent, base, name, members, &block); end
+  class << self
+    def define_struct_class(parent, base, name, members, &block); end
+  end
 end
 
 class Concurrent::Synchronization::Condition < ::Concurrent::Synchronization::LockableObject
@@ -1532,13 +1589,15 @@ class Concurrent::Synchronization::Condition < ::Concurrent::Synchronization::Lo
   def broadcast; end
   def ns_broadcast; end
   def ns_signal; end
-  def ns_wait(timeout = _); end
-  def ns_wait_until(timeout = _, &condition); end
+  def ns_wait(timeout = T.unsafe(nil)); end
+  def ns_wait_until(timeout = T.unsafe(nil), &condition); end
   def signal; end
-  def wait(timeout = _); end
-  def wait_until(timeout = _, &condition); end
+  def wait(timeout = T.unsafe(nil)); end
+  def wait_until(timeout = T.unsafe(nil), &condition); end
 
-  def self.private_new(*args, &block); end
+  class << self
+    def private_new(*args, &block); end
+  end
 end
 
 module Concurrent::Synchronization::ConditionSignalling
@@ -1552,8 +1611,8 @@ end
 class Concurrent::Synchronization::Lock < ::Concurrent::Synchronization::LockableObject
   def broadcast; end
   def signal; end
-  def wait(timeout = _); end
-  def wait_until(timeout = _, &condition); end
+  def wait(timeout = T.unsafe(nil)); end
+  def wait_until(timeout = T.unsafe(nil), &condition); end
 end
 
 class Concurrent::Synchronization::LockableObject < ::Concurrent::Synchronization::MutexLockableObject
@@ -1568,10 +1627,12 @@ class Concurrent::Synchronization::MonitorLockableObject < ::Concurrent::Synchro
 
   protected
 
-  def ns_wait(timeout = _); end
+  def ns_wait(timeout = T.unsafe(nil)); end
   def synchronize; end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 module Concurrent::Synchronization::MriAttrVolatile
@@ -1579,7 +1640,9 @@ module Concurrent::Synchronization::MriAttrVolatile
 
   def full_memory_barrier; end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
@@ -1601,10 +1664,12 @@ class Concurrent::Synchronization::MutexLockableObject < ::Concurrent::Synchroni
 
   protected
 
-  def ns_wait(timeout = _); end
+  def ns_wait(timeout = T.unsafe(nil)); end
   def synchronize; end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 class Concurrent::Synchronization::Object < ::Concurrent::Synchronization::MriObject
@@ -1615,12 +1680,18 @@ class Concurrent::Synchronization::Object < ::Concurrent::Synchronization::MriOb
 
   def __initialize_atomic_fields__; end
 
-  def self.atomic_attribute?(name); end
-  def self.atomic_attributes(inherited = _); end
-  def self.attr_atomic(*names); end
-  def self.ensure_safe_initialization_when_final_fields_are_present; end
-  def self.safe_initialization!; end
-  def self.safe_initialization?; end
+  class << self
+    def atomic_attribute?(name); end
+    def atomic_attributes(inherited = T.unsafe(nil)); end
+    def attr_atomic(*names); end
+    def ensure_safe_initialization_when_final_fields_are_present; end
+    def safe_initialization!; end
+    def safe_initialization?; end
+
+    private
+
+    def define_initialize_atomic_fields; end
+  end
 end
 
 module Concurrent::Synchronization::RbxAttrVolatile
@@ -1628,7 +1699,9 @@ module Concurrent::Synchronization::RbxAttrVolatile
 
   def full_memory_barrier; end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
@@ -1643,10 +1716,12 @@ class Concurrent::Synchronization::RbxLockableObject < ::Concurrent::Synchroniza
 
   def ns_broadcast; end
   def ns_signal; end
-  def ns_wait(timeout = _); end
+  def ns_wait(timeout = T.unsafe(nil)); end
   def synchronize(&block); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 class Concurrent::Synchronization::RbxObject < ::Concurrent::Synchronization::AbstractObject
@@ -1661,7 +1736,9 @@ module Concurrent::Synchronization::TruffleRubyAttrVolatile
 
   def full_memory_barrier; end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
@@ -1696,7 +1773,9 @@ class Concurrent::TVar < ::Concurrent::Synchronization::Object
   def value; end
   def value=(value); end
 
-  def self.new(*args, &block); end
+  class << self
+    def new(*args, &block); end
+  end
 end
 
 class Concurrent::ThreadLocalVar < ::Concurrent::RubyThreadLocalVar
@@ -1721,7 +1800,7 @@ class Concurrent::TimeoutError < ::Concurrent::Error
 end
 
 class Concurrent::TimerSet < ::Concurrent::RubyExecutorService
-  def initialize(opts = _); end
+  def initialize(opts = T.unsafe(nil)); end
 
   def kill; end
   def post(delay, *args, &task); end
@@ -1741,7 +1820,7 @@ class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
   include(::Concurrent::Concern::Dereferenceable)
   include(::Concurrent::Concern::Observable)
 
-  def initialize(opts = _, &task); end
+  def initialize(opts = T.unsafe(nil), &task); end
 
   def execute; end
   def execution_interval; end
@@ -1756,10 +1835,12 @@ class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
   def ns_initialize(opts, &task); end
   def ns_kill_execution; end
   def ns_shutdown_execution; end
-  def schedule_next_task(interval = _); end
+  def schedule_next_task(interval = T.unsafe(nil)); end
   def timeout_task(completion); end
 
-  def self.execute(opts = _, &task); end
+  class << self
+    def execute(opts = T.unsafe(nil), &task); end
+  end
 end
 
 Concurrent::TimerTask::EXECUTION_INTERVAL = T.let(T.unsafe(nil), Integer)
@@ -1776,8 +1857,10 @@ class Concurrent::Transaction
   def valid?; end
   def write(tvar, value); end
 
-  def self.current; end
-  def self.current=(transaction); end
+  class << self
+    def current; end
+    def current=(transaction); end
+  end
 end
 
 Concurrent::Transaction::ABORTED = T.let(T.unsafe(nil), Object)
@@ -1794,10 +1877,12 @@ class Concurrent::Transaction::ReadLogEntry < ::Struct
   def version; end
   def version=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class Concurrent::Tuple
@@ -1828,7 +1913,7 @@ module Concurrent::Utility::EngineDetector
   def on_truffleruby?; end
   def on_windows?; end
   def ruby_engine; end
-  def ruby_version(version = _, comparison, major, minor, patch); end
+  def ruby_version(version = T.unsafe(nil), comparison, major, minor, patch); end
 end
 
 module Concurrent::Utility::NativeExtensionLoader
diff --git a/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi b/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi
index 8403f393d9..1a7227c0a1 100644
--- a/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi
@@ -1,19 +1,22 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `connection_pool` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 class ConnectionPool
-  def initialize(options = _, &block); end
+  def initialize(options = T.unsafe(nil), &block); end
 
   def available; end
   def checkin; end
-  def checkout(options = _); end
+  def checkout(options = T.unsafe(nil)); end
   def shutdown(&block); end
   def size; end
-  def with(options = _); end
+  def with(options = T.unsafe(nil)); end
 
-  def self.wrap(options, &block); end
+  class << self
+    def wrap(options, &block); end
+  end
 end
 
 ConnectionPool::DEFAULTS = T.let(T.unsafe(nil), Hash)
@@ -25,24 +28,24 @@ class ConnectionPool::PoolShuttingDownError < ::ConnectionPool::Error
 end
 
 class ConnectionPool::TimedStack
-  def initialize(size = _, &block); end
+  def initialize(size = T.unsafe(nil), &block); end
 
-  def <<(obj, options = _); end
+  def <<(obj, options = T.unsafe(nil)); end
   def empty?; end
   def length; end
   def max; end
-  def pop(timeout = _, options = _); end
-  def push(obj, options = _); end
+  def pop(timeout = T.unsafe(nil), options = T.unsafe(nil)); end
+  def push(obj, options = T.unsafe(nil)); end
   def shutdown(&block); end
 
   private
 
-  def connection_stored?(options = _); end
+  def connection_stored?(options = T.unsafe(nil)); end
   def current_time; end
-  def fetch_connection(options = _); end
-  def shutdown_connections(options = _); end
-  def store_connection(obj, options = _); end
-  def try_create(options = _); end
+  def fetch_connection(options = T.unsafe(nil)); end
+  def shutdown_connections(options = T.unsafe(nil)); end
+  def store_connection(obj, options = T.unsafe(nil)); end
+  def try_create(options = T.unsafe(nil)); end
 end
 
 class ConnectionPool::TimeoutError < ::Timeout::Error
@@ -51,7 +54,7 @@ end
 ConnectionPool::VERSION = T.let(T.unsafe(nil), String)
 
 class ConnectionPool::Wrapper < ::BasicObject
-  def initialize(options = _, &block); end
+  def initialize(options = T.unsafe(nil), &block); end
 
   def method_missing(name, *args, &block); end
   def pool_available; end
diff --git a/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.4.4.rbi b/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.4.4.rbi
index 198c6b42fc..a20cddbe1d 100644
--- a/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.4.4.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.4.4.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `diff-lcs` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi b/Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi
index 27b1fb4bc6..7c362d5bda 100644
--- a/Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `docile` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi b/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi
index 038b65157b..37d499cd1b 100644
--- a/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `domain_name` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -14,7 +15,7 @@ class DomainName
   def >=(other); end
   def canonical?; end
   def canonical_tld?; end
-  def cookie_domain?(domain, host_only = _); end
+  def cookie_domain?(domain, host_only = T.unsafe(nil)); end
   def domain; end
   def domain_idn; end
   def hostname; end
@@ -30,8 +31,10 @@ class DomainName
   def to_str; end
   def uri_host; end
 
-  def self.etld_data; end
-  def self.normalize(domain); end
+  class << self
+    def etld_data; end
+    def normalize(domain); end
+  end
 end
 
 DomainName::DOT = T.let(T.unsafe(nil), String)
@@ -41,10 +44,12 @@ DomainName::ETLD_DATA = T.let(T.unsafe(nil), Hash)
 DomainName::ETLD_DATA_DATE = T.let(T.unsafe(nil), String)
 
 module DomainName::Punycode
-  def self.decode(string); end
-  def self.decode_hostname(hostname); end
-  def self.encode(string); end
-  def self.encode_hostname(hostname); end
+  class << self
+    def decode(string); end
+    def decode_hostname(hostname); end
+    def encode(string); end
+    def encode_hostname(hostname); end
+  end
 end
 
 class DomainName::Punycode::ArgumentError < ::ArgumentError
diff --git a/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.2.rbi b/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.2.rbi
index 5f2e51557d..3d20f08cba 100644
--- a/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.2.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `elftools` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -184,7 +185,9 @@ ELFTools::Constants::DT::DT_VERNEEDNUM = T.let(T.unsafe(nil), Integer)
 ELFTools::Constants::ELFMAG = T.let(T.unsafe(nil), String)
 
 module ELFTools::Constants::EM
-  def self.mapping(val); end
+  class << self
+    def mapping(val); end
+  end
 end
 
 ELFTools::Constants::EM::EM_386 = T.let(T.unsafe(nil), Integer)
@@ -270,7 +273,9 @@ ELFTools::Constants::EM::EM_TI_C6000 = T.let(T.unsafe(nil), Integer)
 ELFTools::Constants::EM::EM_X86_64 = T.let(T.unsafe(nil), Integer)
 
 module ELFTools::Constants::ET
-  def self.mapping(type); end
+  class << self
+    def mapping(type); end
+  end
 end
 
 ELFTools::Constants::ET::ET_CORE = T.let(T.unsafe(nil), Integer)
@@ -452,7 +457,7 @@ class ELFTools::ELFFile
   def machine; end
   def num_sections; end
   def num_segments; end
-  def offset_from_vma(vma, size = _); end
+  def offset_from_vma(vma, size = T.unsafe(nil)); end
   def patches; end
   def save(filename); end
   def section_at(n); end
@@ -554,7 +559,7 @@ class ELFTools::Sections::RelocationSection < ::ELFTools::Sections::Section
 end
 
 class ELFTools::Sections::Section
-  def initialize(header, stream, offset_from_vma: _, strtab: _, **_kwargs); end
+  def initialize(header, stream, offset_from_vma: T.unsafe(nil), strtab: T.unsafe(nil), **_kwargs); end
 
   def data; end
   def header; end
@@ -563,7 +568,9 @@ class ELFTools::Sections::Section
   def stream; end
   def type; end
 
-  def self.create(header, stream, *args, **kwargs); end
+  class << self
+    def create(header, stream, *args, **kwargs); end
+  end
 end
 
 class ELFTools::Sections::StrTabSection < ::ELFTools::Sections::Section
@@ -571,7 +578,7 @@ class ELFTools::Sections::StrTabSection < ::ELFTools::Sections::Section
 end
 
 class ELFTools::Sections::SymTabSection < ::ELFTools::Sections::Section
-  def initialize(header, stream, section_at: _, **_kwargs); end
+  def initialize(header, stream, section_at: T.unsafe(nil), **_kwargs); end
 
   def each_symbols(&block); end
   def num_symbols; end
@@ -586,7 +593,7 @@ class ELFTools::Sections::SymTabSection < ::ELFTools::Sections::Section
 end
 
 class ELFTools::Sections::Symbol
-  def initialize(header, stream, symstr: _); end
+  def initialize(header, stream, symstr: T.unsafe(nil)); end
 
   def header; end
   def name; end
@@ -612,10 +619,10 @@ class ELFTools::Segments::LoadSegment < ::ELFTools::Segments::Segment
   def mem_head; end
   def mem_size; end
   def mem_tail; end
-  def offset_in?(offset, size = _); end
+  def offset_in?(offset, size = T.unsafe(nil)); end
   def offset_to_vma(offset); end
   def size; end
-  def vma_in?(vma, size = _); end
+  def vma_in?(vma, size = T.unsafe(nil)); end
   def vma_to_offset(vma); end
 end
 
@@ -627,7 +634,7 @@ class ELFTools::Segments::NoteSegment < ::ELFTools::Segments::Segment
 end
 
 class ELFTools::Segments::Segment
-  def initialize(header, stream, offset_from_vma: _); end
+  def initialize(header, stream, offset_from_vma: T.unsafe(nil)); end
 
   def data; end
   def executable?; end
@@ -637,30 +644,40 @@ class ELFTools::Segments::Segment
   def type; end
   def writable?; end
 
-  def self.create(header, stream, *args, **kwargs); end
+  class << self
+    def create(header, stream, *args, **kwargs); end
+  end
 end
 
 module ELFTools::Structs
 end
 
 class ELFTools::Structs::ELF32_Phdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF32_sym < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF64_Phdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF64_sym < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELFStruct < ::BinData::Record
@@ -670,44 +687,58 @@ class ELFTools::Structs::ELFStruct < ::BinData::Record
   def offset=(_); end
   def patches; end
 
-  def self.inherited(subclass); end
-  def self.new(*args); end
-  def self.pack(val, bytes); end
-  def self.self_endian; end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+    def pack(val, bytes); end
+    def self_endian; end
+  end
 end
 
 ELFTools::Structs::ELFStruct::CHOICE_SIZE_T = T.let(T.unsafe(nil), Hash)
 
 class ELFTools::Structs::ELF_Dyn < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF_Ehdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF_Nhdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 ELFTools::Structs::ELF_Phdr = T.let(T.unsafe(nil), Hash)
 
 class ELFTools::Structs::ELF_Rel < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF_Rela < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF_Shdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
-  def self.new(*args); end
+  class << self
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 ELFTools::Structs::ELF_sym = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi b/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi
index b6c0872fc5..c36660a836 100644
--- a/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `highline` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi b/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi
index 27b1fb4bc6..362cb7e593 100644
--- a/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `hpricot` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi b/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi
index 8f325c0eae..f1026915d8 100644
--- a/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `http-cookie` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -29,7 +30,7 @@ class HTTP::Cookie
   def dot_domain; end
   def encode_with(coder); end
   def expire!; end
-  def expired?(time = _); end
+  def expired?(time = T.unsafe(nil)); end
   def expires; end
   def expires=(t); end
   def expires_at; end
@@ -63,9 +64,11 @@ class HTTP::Cookie
   def value=(value); end
   def yaml_initialize(tag, map); end
 
-  def self.cookie_value(cookies); end
-  def self.cookie_value_to_hash(cookie_value); end
-  def self.path_match?(base_path, target_path); end
+  class << self
+    def cookie_value(cookies); end
+    def cookie_value_to_hash(cookie_value); end
+    def path_match?(base_path, target_path); end
+  end
 end
 
 HTTP::Cookie::MAX_COOKIES_PER_DOMAIN = T.let(T.unsafe(nil), Integer)
@@ -77,22 +80,24 @@ HTTP::Cookie::MAX_LENGTH = T.let(T.unsafe(nil), Integer)
 HTTP::Cookie::PERSISTENT_PROPERTIES = T.let(T.unsafe(nil), Array)
 
 class HTTP::Cookie::Scanner < ::StringScanner
-  def initialize(string, logger = _); end
+  def initialize(string, logger = T.unsafe(nil)); end
 
   def parse_cookie_date(s); end
   def scan_cookie; end
   def scan_dquoted; end
   def scan_name; end
-  def scan_name_value(comma_as_separator = _); end
+  def scan_name_value(comma_as_separator = T.unsafe(nil)); end
   def scan_set_cookie; end
-  def scan_value(comma_as_separator = _); end
+  def scan_value(comma_as_separator = T.unsafe(nil)); end
   def skip_wsp; end
 
   private
 
   def tuple_to_time(day_of_month, month, year, time); end
 
-  def self.quote(s); end
+  class << self
+    def quote(s); end
+  end
 end
 
 HTTP::Cookie::Scanner::RE_BAD_CHAR = T.let(T.unsafe(nil), Regexp)
@@ -112,17 +117,17 @@ class HTTP::CookieJar
   include(::Mechanize::CookieJarIMethods)
   include(::Enumerable)
 
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def <<(cookie); end
-  def cleanup(session = _); end
+  def cleanup(session = T.unsafe(nil)); end
   def clear; end
-  def cookies(url = _); end
+  def cookies(url = T.unsafe(nil)); end
   def delete(cookie); end
-  def each(uri = _, &block); end
-  def empty?(url = _); end
+  def each(uri = T.unsafe(nil), &block); end
+  def empty?(url = T.unsafe(nil)); end
   def load(readable, *options); end
-  def parse(set_cookie, origin, options = _); end
+  def parse(set_cookie, origin, options = T.unsafe(nil)); end
   def save(writable, *options); end
   def store; end
 
@@ -131,11 +136,13 @@ class HTTP::CookieJar
   def get_impl(base, value, *args); end
   def initialize_copy(other); end
 
-  def self.const_missing(name); end
+  class << self
+    def const_missing(name); end
+  end
 end
 
 class HTTP::CookieJar::AbstractSaver
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def load(io, jar); end
   def save(io, jar); end
@@ -144,9 +151,11 @@ class HTTP::CookieJar::AbstractSaver
 
   def default_options; end
 
-  def self.class_to_symbol(klass); end
-  def self.implementation(symbol); end
-  def self.inherited(subclass); end
+  class << self
+    def class_to_symbol(klass); end
+    def implementation(symbol); end
+    def inherited(subclass); end
+  end
 end
 
 class HTTP::CookieJar::YAMLSaver < ::HTTP::CookieJar::AbstractSaver
@@ -162,13 +171,13 @@ class HTTP::CookieJar::AbstractStore
   include(::MonitorMixin)
   include(::Enumerable)
 
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def add(cookie); end
-  def cleanup(session = _); end
+  def cleanup(session = T.unsafe(nil)); end
   def clear; end
   def delete(cookie); end
-  def each(uri = _, &block); end
+  def each(uri = T.unsafe(nil), &block); end
   def empty?; end
 
   private
@@ -176,9 +185,11 @@ class HTTP::CookieJar::AbstractStore
   def default_options; end
   def initialize_copy(other); end
 
-  def self.class_to_symbol(klass); end
-  def self.implementation(symbol); end
-  def self.inherited(subclass); end
+  class << self
+    def class_to_symbol(klass); end
+    def implementation(symbol); end
+    def inherited(subclass); end
+  end
 end
 
 class HTTP::CookieJar::CookiestxtSaver < ::HTTP::CookieJar::AbstractSaver
@@ -201,14 +212,14 @@ HTTP::CookieJar::CookiestxtSaver::RE_HTTPONLY_PREFIX = T.let(T.unsafe(nil), Rege
 HTTP::CookieJar::CookiestxtSaver::True = T.let(T.unsafe(nil), String)
 
 class HTTP::CookieJar::HashStore < ::HTTP::CookieJar::AbstractStore
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def add(cookie); end
-  def cleanup(session = _); end
+  def cleanup(session = T.unsafe(nil)); end
   def clear; end
   def default_options; end
   def delete(cookie); end
-  def each(uri = _); end
+  def each(uri = T.unsafe(nil)); end
 
   private
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.5.rbi b/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.5.rbi
index 198c6b42fc..a86f016cc2 100644
--- a/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.5.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.5.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `i18n` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/mechanize@2.7.6.rbi b/Library/Homebrew/sorbet/rbi/gems/mechanize@2.7.6.rbi
index cec901fc1d..702f5f5c73 100644
--- a/Library/Homebrew/sorbet/rbi/gems/mechanize@2.7.6.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/mechanize@2.7.6.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `mechanize` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -8,17 +9,17 @@ class HTTP::CookieJar
   include(::Mechanize::CookieJarIMethods)
   include(::Enumerable)
 
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def <<(cookie); end
-  def cleanup(session = _); end
+  def cleanup(session = T.unsafe(nil)); end
   def clear; end
-  def cookies(url = _); end
+  def cookies(url = T.unsafe(nil)); end
   def delete(cookie); end
-  def each(uri = _, &block); end
-  def empty?(url = _); end
+  def each(uri = T.unsafe(nil), &block); end
+  def empty?(url = T.unsafe(nil)); end
   def load(readable, *options); end
-  def parse(set_cookie, origin, options = _); end
+  def parse(set_cookie, origin, options = T.unsafe(nil)); end
   def save(writable, *options); end
   def store; end
 
@@ -27,17 +28,19 @@ class HTTP::CookieJar
   def get_impl(base, value, *args); end
   def initialize_copy(other); end
 
-  def self.const_missing(name); end
+  class << self
+    def const_missing(name); end
+  end
 end
 
 class Mechanize
-  def initialize(connection_name = _); end
+  def initialize(connection_name = T.unsafe(nil)); end
 
-  def add_auth(uri, user, password, realm = _, domain = _); end
+  def add_auth(uri, user, password, realm = T.unsafe(nil), domain = T.unsafe(nil)); end
   def agent; end
-  def auth(user, password, domain = _); end
+  def auth(user, password, domain = T.unsafe(nil)); end
   def back; end
-  def basic_auth(user, password, domain = _); end
+  def basic_auth(user, password, domain = T.unsafe(nil)); end
   def ca_file; end
   def ca_file=(ca_file); end
   def cert; end
@@ -55,8 +58,8 @@ class Mechanize
   def current_page; end
   def default_encoding; end
   def default_encoding=(_); end
-  def delete(uri, query_params = _, headers = _); end
-  def download(uri, io_or_filename, parameters = _, referer = _, headers = _); end
+  def delete(uri, query_params = T.unsafe(nil), headers = T.unsafe(nil)); end
+  def download(uri, io_or_filename, parameters = T.unsafe(nil), referer = T.unsafe(nil), headers = T.unsafe(nil)); end
   def follow_meta_refresh; end
   def follow_meta_refresh=(follow); end
   def follow_meta_refresh_self; end
@@ -65,11 +68,11 @@ class Mechanize
   def follow_redirect?; end
   def force_default_encoding; end
   def force_default_encoding=(_); end
-  def get(uri, parameters = _, referer = _, headers = _); end
+  def get(uri, parameters = T.unsafe(nil), referer = T.unsafe(nil), headers = T.unsafe(nil)); end
   def get_file(url); end
   def gzip_enabled; end
   def gzip_enabled=(enabled); end
-  def head(uri, query_params = _, headers = _); end
+  def head(uri, query_params = T.unsafe(nil), headers = T.unsafe(nil)); end
   def history; end
   def history_added; end
   def history_added=(_); end
@@ -98,7 +101,7 @@ class Mechanize
   def pass; end
   def pass=(pass); end
   def pluggable_parser; end
-  def post(uri, query = _, headers = _); end
+  def post(uri, query = T.unsafe(nil), headers = T.unsafe(nil)); end
   def post_connect_hooks; end
   def pre_connect_hooks; end
   def pretty_print(q); end
@@ -106,7 +109,7 @@ class Mechanize
   def proxy_pass; end
   def proxy_port; end
   def proxy_user; end
-  def put(uri, entity, headers = _); end
+  def put(uri, entity, headers = T.unsafe(nil)); end
   def read_timeout; end
   def read_timeout=(read_timeout); end
   def redirect_ok; end
@@ -115,7 +118,7 @@ class Mechanize
   def redirection_limit=(limit); end
   def request_headers; end
   def request_headers=(request_headers); end
-  def request_with_entity(verb, uri, entity, headers = _); end
+  def request_with_entity(verb, uri, entity, headers = T.unsafe(nil)); end
   def reset; end
   def resolve(link); end
   def retry_change_requests; end
@@ -124,11 +127,11 @@ class Mechanize
   def robots=(enabled); end
   def scheme_handlers; end
   def scheme_handlers=(scheme_handlers); end
-  def set_proxy(address, port, user = _, password = _); end
+  def set_proxy(address, port, user = T.unsafe(nil), password = T.unsafe(nil)); end
   def shutdown; end
   def ssl_version; end
   def ssl_version=(ssl_version); end
-  def submit(form, button = _, headers = _); end
+  def submit(form, button = T.unsafe(nil), headers = T.unsafe(nil)); end
   def transact; end
   def user_agent; end
   def user_agent=(user_agent); end
@@ -145,14 +148,16 @@ class Mechanize
   private
 
   def add_to_history(page); end
-  def post_form(uri, form, headers = _); end
+  def post_form(uri, form, headers = T.unsafe(nil)); end
 
-  def self.html_parser; end
-  def self.html_parser=(_); end
-  def self.inherited(child); end
-  def self.log; end
-  def self.log=(_); end
-  def self.start; end
+  class << self
+    def html_parser; end
+    def html_parser=(_); end
+    def inherited(child); end
+    def log; end
+    def log=(_); end
+    def start; end
+  end
 end
 
 Mechanize::AGENT_ALIASES = T.let(T.unsafe(nil), Hash)
@@ -171,14 +176,14 @@ Mechanize::Cookie = HTTP::Cookie
 module Mechanize::CookieCMethods
   include(::Mechanize::CookieDeprecated)
 
-  def parse(arg1, arg2, arg3 = _, &block); end
+  def parse(arg1, arg2, arg3 = T.unsafe(nil), &block); end
 end
 
 module Mechanize::CookieDeprecated
 
   private
 
-  def __deprecated__(to = _); end
+  def __deprecated__(to = T.unsafe(nil)); end
 end
 
 module Mechanize::CookieIMethods
@@ -195,7 +200,7 @@ end
 module Mechanize::CookieJarIMethods
   include(::Mechanize::CookieDeprecated)
 
-  def add(arg1, arg2 = _); end
+  def add(arg1, arg2 = T.unsafe(nil)); end
   def add!(cookie); end
   def clear!; end
   def dump_cookiestxt(io); end
@@ -205,31 +210,33 @@ module Mechanize::CookieJarIMethods
 end
 
 class Mechanize::DirectorySaver < ::Mechanize::Download
-  def initialize(uri = _, response = _, body_io = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
 
-  def self.decode_filename?; end
-  def self.directory; end
-  def self.overwrite?; end
-  def self.save_to(directory, options = _); end
+  class << self
+    def decode_filename?; end
+    def directory; end
+    def overwrite?; end
+    def save_to(directory, options = T.unsafe(nil)); end
+  end
 end
 
 class Mechanize::Download
   include(::Mechanize::Parser)
 
-  def initialize(uri = _, response = _, body_io = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
 
   def body; end
   def body_io; end
   def content; end
   def filename; end
   def filename=(_); end
-  def save(filename = _); end
-  def save!(filename = _); end
-  def save_as(filename = _); end
+  def save(filename = T.unsafe(nil)); end
+  def save!(filename = T.unsafe(nil)); end
+  def save_as(filename = T.unsafe(nil)); end
 end
 
 module Mechanize::ElementMatcher
-  def elements_with(singular, plural = _); end
+  def elements_with(singular, plural = T.unsafe(nil)); end
 end
 
 class Mechanize::ElementNotFoundError < ::Mechanize::Error
@@ -246,22 +253,24 @@ end
 class Mechanize::File
   include(::Mechanize::Parser)
 
-  def initialize(uri = _, response = _, body = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil)); end
 
   def body; end
   def body=(_); end
   def content; end
   def filename; end
   def filename=(_); end
-  def save(filename = _); end
-  def save!(filename = _); end
-  def save_as(filename = _); end
+  def save(filename = T.unsafe(nil)); end
+  def save!(filename = T.unsafe(nil)); end
+  def save_as(filename = T.unsafe(nil)); end
 end
 
 class Mechanize::FileConnection
   def request(uri, request); end
 
-  def self.new(*a); end
+  class << self
+    def new(*a); end
+  end
 end
 
 class Mechanize::FileRequest
@@ -297,39 +306,39 @@ class Mechanize::FileResponse
 end
 
 class Mechanize::FileSaver < ::Mechanize::Download
-  def initialize(uri = _, response = _, body_io = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
 
   def filename; end
-  def save_as(filename = _); end
+  def save_as(filename = T.unsafe(nil)); end
 end
 
 class Mechanize::Form
   extend(::Forwardable)
   extend(::Mechanize::ElementMatcher)
 
-  def initialize(node, mech = _, page = _); end
+  def initialize(node, mech = T.unsafe(nil), page = T.unsafe(nil)); end
 
   def [](field_name); end
   def []=(field_name, value); end
   def action; end
   def action=(_); end
   def add_button_to_query(button); end
-  def add_field!(field_name, value = _); end
+  def add_field!(field_name, value = T.unsafe(nil)); end
   def at(*args, &block); end
   def at_css(*args, &block); end
   def at_xpath(*args, &block); end
-  def build_query(buttons = _); end
-  def button(criteria = _); end
-  def button_with(criteria = _); end
-  def button_with!(criteria = _); end
+  def build_query(buttons = T.unsafe(nil)); end
+  def button(criteria = T.unsafe(nil)); end
+  def button_with(criteria = T.unsafe(nil)); end
+  def button_with!(criteria = T.unsafe(nil)); end
   def buttons; end
-  def buttons_with(criteria = _); end
-  def checkbox(criteria = _); end
-  def checkbox_with(criteria = _); end
-  def checkbox_with!(criteria = _); end
+  def buttons_with(criteria = T.unsafe(nil)); end
+  def checkbox(criteria = T.unsafe(nil)); end
+  def checkbox_with(criteria = T.unsafe(nil)); end
+  def checkbox_with!(criteria = T.unsafe(nil)); end
   def checkboxes; end
-  def checkboxes_with(criteria = _); end
-  def click_button(button = _); end
+  def checkboxes_with(criteria = T.unsafe(nil)); end
+  def click_button(button = T.unsafe(nil)); end
   def css(*args, &block); end
   def delete_field!(field_name); end
   def dom_class; end
@@ -339,16 +348,16 @@ class Mechanize::Form
   def encoding=(_); end
   def enctype; end
   def enctype=(_); end
-  def field(criteria = _); end
-  def field_with(criteria = _); end
-  def field_with!(criteria = _); end
+  def field(criteria = T.unsafe(nil)); end
+  def field_with(criteria = T.unsafe(nil)); end
+  def field_with!(criteria = T.unsafe(nil)); end
   def fields; end
-  def fields_with(criteria = _); end
-  def file_upload(criteria = _); end
-  def file_upload_with(criteria = _); end
-  def file_upload_with!(criteria = _); end
+  def fields_with(criteria = T.unsafe(nil)); end
+  def file_upload(criteria = T.unsafe(nil)); end
+  def file_upload_with(criteria = T.unsafe(nil)); end
+  def file_upload_with!(criteria = T.unsafe(nil)); end
   def file_uploads; end
-  def file_uploads_with(criteria = _); end
+  def file_uploads_with(criteria = T.unsafe(nil)); end
   def form_node; end
   def has_field?(field_name); end
   def has_key?(field_name); end
@@ -368,24 +377,24 @@ class Mechanize::Form
   def node; end
   def page; end
   def pretty_print(q); end
-  def radiobutton(criteria = _); end
-  def radiobutton_with(criteria = _); end
-  def radiobutton_with!(criteria = _); end
+  def radiobutton(criteria = T.unsafe(nil)); end
+  def radiobutton_with(criteria = T.unsafe(nil)); end
+  def radiobutton_with!(criteria = T.unsafe(nil)); end
   def radiobuttons; end
-  def radiobuttons_with(criteria = _); end
+  def radiobuttons_with(criteria = T.unsafe(nil)); end
   def request_data; end
   def reset; end
   def reset_button?(button_name); end
   def resets; end
   def save_hash_field_order; end
   def search(*args, &block); end
-  def select_buttons(selector, method = _); end
-  def select_checkboxes(selector, method = _); end
-  def select_fields(selector, method = _); end
-  def select_file_uploads(selector, method = _); end
-  def select_radiobuttons(selector, method = _); end
-  def set_fields(fields = _); end
-  def submit(button = _, headers = _); end
+  def select_buttons(selector, method = T.unsafe(nil)); end
+  def select_checkboxes(selector, method = T.unsafe(nil)); end
+  def select_fields(selector, method = T.unsafe(nil)); end
+  def select_file_uploads(selector, method = T.unsafe(nil)); end
+  def select_radiobuttons(selector, method = T.unsafe(nil)); end
+  def set_fields(fields = T.unsafe(nil)); end
+  def submit(button = T.unsafe(nil), headers = T.unsafe(nil)); end
   def submit_button?(button_name); end
   def submits; end
   def text_field?(field_name); end
@@ -397,13 +406,13 @@ class Mechanize::Form
 
   private
 
-  def file_to_multipart(file, buf = _); end
+  def file_to_multipart(file, buf = T.unsafe(nil)); end
   def from_native_charset(str); end
   def mime_value_quote(str); end
-  def param_to_multipart(name, value, buf = _); end
+  def param_to_multipart(name, value, buf = T.unsafe(nil)); end
   def parse; end
   def proc_query(field); end
-  def rand_string(len = _); end
+  def rand_string(len = T.unsafe(nil)); end
 end
 
 class Mechanize::Form::Button < ::Mechanize::Form::Field
@@ -419,7 +428,7 @@ end
 class Mechanize::Form::Field
   extend(::Forwardable)
 
-  def initialize(node, value = _); end
+  def initialize(node, value = T.unsafe(nil)); end
 
   def <=>(other); end
   def at(*args, &block); end
@@ -470,10 +479,10 @@ class Mechanize::Form::ImageButton < ::Mechanize::Form::Button
 end
 
 class Mechanize::Form::Keygen < ::Mechanize::Form::Field
-  def initialize(node, value = _); end
+  def initialize(node, value = T.unsafe(nil)); end
 
   def challenge; end
-  def generate_key(key_size = _); end
+  def generate_key(key_size = T.unsafe(nil)); end
   def key; end
 end
 
@@ -482,16 +491,16 @@ class Mechanize::Form::MultiSelectList < ::Mechanize::Form::Field
 
   def initialize(node); end
 
-  def option(criteria = _); end
-  def option_with(criteria = _); end
-  def option_with!(criteria = _); end
+  def option(criteria = T.unsafe(nil)); end
+  def option_with(criteria = T.unsafe(nil)); end
+  def option_with!(criteria = T.unsafe(nil)); end
   def options; end
   def options=(_); end
-  def options_with(criteria = _); end
+  def options_with(criteria = T.unsafe(nil)); end
   def query_value; end
   def select_all; end
   def select_none; end
-  def select_options(selector, method = _); end
+  def select_options(selector, method = T.unsafe(nil)); end
   def selected_options; end
   def value; end
   def value=(values); end
@@ -565,10 +574,10 @@ class Mechanize::HTTP
 end
 
 class Mechanize::HTTP::Agent
-  def initialize(connection_name = _); end
+  def initialize(connection_name = T.unsafe(nil)); end
 
-  def add_auth(uri, user, password, realm = _, domain = _); end
-  def add_default_auth(user, password, domain = _); end
+  def add_auth(uri, user, password, realm = T.unsafe(nil), domain = T.unsafe(nil)); end
+  def add_default_auth(user, password, domain = T.unsafe(nil)); end
   def allowed_error_codes; end
   def allowed_error_codes=(_); end
   def auth_store; end
@@ -595,7 +604,7 @@ class Mechanize::HTTP::Agent
   def digest_challenges; end
   def disable_keep_alive(request); end
   def enable_gzip(request); end
-  def fetch(uri, method = _, headers = _, params = _, referer = _, redirects = _); end
+  def fetch(uri, method = T.unsafe(nil), headers = T.unsafe(nil), params = T.unsafe(nil), referer = T.unsafe(nil), redirects = T.unsafe(nil)); end
   def follow_meta_refresh; end
   def follow_meta_refresh=(_); end
   def follow_meta_refresh_self; end
@@ -608,12 +617,12 @@ class Mechanize::HTTP::Agent
   def history=(_); end
   def hook_content_encoding(response, uri, response_body_io); end
   def http; end
-  def http_request(uri, method, params = _); end
+  def http_request(uri, method, params = T.unsafe(nil)); end
   def idle_timeout; end
   def idle_timeout=(timeout); end
   def ignore_bad_chunking; end
   def ignore_bad_chunking=(_); end
-  def inflate(compressed, window_bits = _); end
+  def inflate(compressed, window_bits = T.unsafe(nil)); end
   def keep_alive; end
   def keep_alive=(_); end
   def log; end
@@ -639,7 +648,7 @@ class Mechanize::HTTP::Agent
   def redirect_ok=(_); end
   def redirection_limit; end
   def redirection_limit=(_); end
-  def request_add_headers(request, headers = _); end
+  def request_add_headers(request, headers = T.unsafe(nil)); end
   def request_auth(request, uri); end
   def request_auth_digest(request, uri, realm, base_uri, iis); end
   def request_cookies(request, uri); end
@@ -651,7 +660,7 @@ class Mechanize::HTTP::Agent
   def request_referer(request, uri, referer); end
   def request_user_agent(request); end
   def reset; end
-  def resolve(uri, referer = _); end
+  def resolve(uri, referer = T.unsafe(nil)); end
   def resolve_parameters(uri, method, parameters); end
   def response_authenticate(response, page, uri, request, headers, params, referer); end
   def response_content_encoding(response, body_io); end
@@ -660,7 +669,7 @@ class Mechanize::HTTP::Agent
   def response_log(response); end
   def response_parse(response, body_io, uri); end
   def response_read(response, request, uri); end
-  def response_redirect(response, method, page, redirects, headers, referer = _); end
+  def response_redirect(response, method, page, redirects, headers, referer = T.unsafe(nil)); end
   def retry_change_requests; end
   def retry_change_requests=(retri); end
   def robots; end
@@ -674,8 +683,8 @@ class Mechanize::HTTP::Agent
   def save_cookies(uri, set_cookie); end
   def scheme_handlers; end
   def scheme_handlers=(_); end
-  def secure_resolve!(uri, referer = _); end
-  def set_proxy(addr, port = _, user = _, pass = _); end
+  def secure_resolve!(uri, referer = T.unsafe(nil)); end
+  def set_proxy(addr, port = T.unsafe(nil), user = T.unsafe(nil), pass = T.unsafe(nil)); end
   def shutdown; end
   def ssl_version; end
   def ssl_version=(ssl_version); end
@@ -704,10 +713,12 @@ class Mechanize::HTTP::AuthChallenge < ::Struct
   def scheme=(_); end
   def to_s; end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class Mechanize::HTTP::AuthRealm
@@ -725,13 +736,13 @@ end
 class Mechanize::HTTP::AuthStore
   def initialize; end
 
-  def add_auth(uri, user, pass, realm = _, domain = _); end
-  def add_default_auth(user, pass, domain = _); end
+  def add_auth(uri, user, pass, realm = T.unsafe(nil), domain = T.unsafe(nil)); end
+  def add_default_auth(user, pass, domain = T.unsafe(nil)); end
   def auth_accounts; end
   def credentials?(uri, challenges); end
   def credentials_for(uri, realm); end
   def default_auth; end
-  def remove_auth(uri, realm = _); end
+  def remove_auth(uri, realm = T.unsafe(nil)); end
 end
 
 class Mechanize::HTTP::ContentDisposition < ::Struct
@@ -750,16 +761,18 @@ class Mechanize::HTTP::ContentDisposition < ::Struct
   def type; end
   def type=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class Mechanize::HTTP::ContentDispositionParser
   def initialize; end
 
-  def parse(content_disposition, header = _); end
+  def parse(content_disposition, header = T.unsafe(nil)); end
   def parse_parameters; end
   def rfc_2045_quoted_string; end
   def rfc_2045_token; end
@@ -768,7 +781,9 @@ class Mechanize::HTTP::ContentDispositionParser
   def scanner=(_); end
   def spaces; end
 
-  def self.parse(content_disposition); end
+  class << self
+    def parse(content_disposition); end
+  end
 end
 
 class Mechanize::HTTP::WWWAuthenticateParser
@@ -793,15 +808,15 @@ class Mechanize::Headers < ::Hash
 end
 
 class Mechanize::History < ::Array
-  def initialize(max_size = _); end
+  def initialize(max_size = T.unsafe(nil)); end
 
-  def <<(page, uri = _); end
+  def <<(page, uri = T.unsafe(nil)); end
   def clear; end
   def inspect; end
   def max_size; end
   def max_size=(_); end
   def pop; end
-  def push(page, uri = _); end
+  def push(page, uri = T.unsafe(nil)); end
   def shift; end
   def visited?(uri); end
   def visited_page(uri); end
@@ -819,55 +834,55 @@ class Mechanize::Page < ::Mechanize::File
   extend(::Forwardable)
   extend(::Mechanize::ElementMatcher)
 
-  def initialize(uri = _, response = _, body = _, code = _, mech = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil), mech = T.unsafe(nil)); end
 
   def %(*args, &block); end
   def /(*args, &block); end
   def at(*args, &block); end
   def at_css(*args, &block); end
   def at_xpath(*args, &block); end
-  def base(criteria = _); end
-  def base_with(criteria = _); end
-  def base_with!(criteria = _); end
+  def base(criteria = T.unsafe(nil)); end
+  def base_with(criteria = T.unsafe(nil)); end
+  def base_with!(criteria = T.unsafe(nil)); end
   def bases; end
-  def bases_with(criteria = _); end
+  def bases_with(criteria = T.unsafe(nil)); end
   def canonical_uri; end
   def content_type; end
   def css(*args, &block); end
   def detected_encoding; end
   def encoding; end
   def encoding=(encoding); end
-  def encoding_error?(parser = _); end
+  def encoding_error?(parser = T.unsafe(nil)); end
   def encodings; end
-  def form(criteria = _); end
-  def form_with(criteria = _); end
-  def form_with!(criteria = _); end
+  def form(criteria = T.unsafe(nil)); end
+  def form_with(criteria = T.unsafe(nil)); end
+  def form_with!(criteria = T.unsafe(nil)); end
   def forms; end
-  def forms_with(criteria = _); end
-  def frame(criteria = _); end
-  def frame_with(criteria = _); end
-  def frame_with!(criteria = _); end
+  def forms_with(criteria = T.unsafe(nil)); end
+  def frame(criteria = T.unsafe(nil)); end
+  def frame_with(criteria = T.unsafe(nil)); end
+  def frame_with!(criteria = T.unsafe(nil)); end
   def frames; end
-  def frames_with(criteria = _); end
-  def iframe(criteria = _); end
-  def iframe_with(criteria = _); end
-  def iframe_with!(criteria = _); end
+  def frames_with(criteria = T.unsafe(nil)); end
+  def iframe(criteria = T.unsafe(nil)); end
+  def iframe_with(criteria = T.unsafe(nil)); end
+  def iframe_with!(criteria = T.unsafe(nil)); end
   def iframes; end
-  def iframes_with(criteria = _); end
-  def image(criteria = _); end
+  def iframes_with(criteria = T.unsafe(nil)); end
+  def image(criteria = T.unsafe(nil)); end
   def image_urls; end
-  def image_with(criteria = _); end
-  def image_with!(criteria = _); end
+  def image_with(criteria = T.unsafe(nil)); end
+  def image_with!(criteria = T.unsafe(nil)); end
   def images; end
-  def images_with(criteria = _); end
+  def images_with(criteria = T.unsafe(nil)); end
   def inspect; end
   def labels; end
   def labels_hash; end
-  def link(criteria = _); end
-  def link_with(criteria = _); end
-  def link_with!(criteria = _); end
+  def link(criteria = T.unsafe(nil)); end
+  def link_with(criteria = T.unsafe(nil)); end
+  def link_with!(criteria = T.unsafe(nil)); end
   def links; end
-  def links_with(criteria = _); end
+  def links_with(criteria = T.unsafe(nil)); end
   def mech; end
   def mech=(_); end
   def meta_charset; end
@@ -878,12 +893,12 @@ class Mechanize::Page < ::Mechanize::File
   def response_header_charset; end
   def root; end
   def search(*args, &block); end
-  def select_bases(selector, method = _); end
-  def select_forms(selector, method = _); end
-  def select_frames(selector, method = _); end
-  def select_iframes(selector, method = _); end
-  def select_images(selector, method = _); end
-  def select_links(selector, method = _); end
+  def select_bases(selector, method = T.unsafe(nil)); end
+  def select_forms(selector, method = T.unsafe(nil)); end
+  def select_frames(selector, method = T.unsafe(nil)); end
+  def select_iframes(selector, method = T.unsafe(nil)); end
+  def select_images(selector, method = T.unsafe(nil)); end
+  def select_links(selector, method = T.unsafe(nil)); end
   def title; end
   def xpath(*args, &block); end
 
@@ -891,11 +906,13 @@ class Mechanize::Page < ::Mechanize::File
 
   def html_body; end
 
-  def self.charset(content_type); end
-  def self.charset_from_content_type(content_type); end
-  def self.meta_charset(body); end
-  def self.meta_content_type(body); end
-  def self.response_header_charset(response); end
+  class << self
+    def charset(content_type); end
+    def charset_from_content_type(content_type); end
+    def meta_charset(body); end
+    def meta_content_type(body); end
+    def response_header_charset(response); end
+  end
 end
 
 class Mechanize::Page::Base < ::Mechanize::Page::Link
@@ -921,7 +938,7 @@ class Mechanize::Page::Image
   def dom_class; end
   def dom_id; end
   def extname; end
-  def fetch(parameters = _, referer = _, headers = _); end
+  def fetch(parameters = T.unsafe(nil), referer = T.unsafe(nil), headers = T.unsafe(nil)); end
   def height; end
   def image_referer; end
   def inspect; end
@@ -975,14 +992,16 @@ class Mechanize::Page::Link
 end
 
 class Mechanize::Page::MetaRefresh < ::Mechanize::Page::Link
-  def initialize(node, page, delay, href, link_self = _); end
+  def initialize(node, page, delay, href, link_self = T.unsafe(nil)); end
 
   def delay; end
   def link_self; end
   def noreferrer?; end
 
-  def self.from_node(node, page, uri = _); end
-  def self.parse(content, base_uri = _); end
+  class << self
+    def from_node(node, page, uri = T.unsafe(nil)); end
+    def parse(content, base_uri = T.unsafe(nil)); end
+  end
 end
 
 Mechanize::Page::MetaRefresh::CONTENT_REGEXP = T.let(T.unsafe(nil), Regexp)
@@ -998,7 +1017,7 @@ module Mechanize::Parser
   def code; end
   def code=(_); end
   def each(*args, &block); end
-  def extract_filename(full_path = _); end
+  def extract_filename(full_path = T.unsafe(nil)); end
   def fill_header(response); end
   def find_free_name(filename); end
   def header; end
@@ -1051,7 +1070,7 @@ class Mechanize::RedirectNotGetOrHeadError < ::Mechanize::Error
 end
 
 class Mechanize::ResponseCodeError < ::Mechanize::Error
-  def initialize(page, message = _); end
+  def initialize(page, message = T.unsafe(nil)); end
 
   def inspect; end
   def page; end
@@ -1097,14 +1116,20 @@ class Mechanize::UnsupportedSchemeError < ::Mechanize::Error
 end
 
 class Mechanize::Util
-  def self.build_query_string(parameters, enc = _); end
-  def self.detect_charset(src); end
-  def self.each_parameter(parameters, &block); end
-  def self.from_native_charset(s, code, ignore_encoding_error = _, log = _); end
-  def self.guess_encoding(src); end
-  def self.html_unescape(s); end
-  def self.uri_escape(str, unsafe = _); end
-  def self.uri_unescape(str); end
+  class << self
+    def build_query_string(parameters, enc = T.unsafe(nil)); end
+    def detect_charset(src); end
+    def each_parameter(parameters, &block); end
+    def from_native_charset(s, code, ignore_encoding_error = T.unsafe(nil), log = T.unsafe(nil)); end
+    def guess_encoding(src); end
+    def html_unescape(s); end
+    def uri_escape(str, unsafe = T.unsafe(nil)); end
+    def uri_unescape(str); end
+
+    private
+
+    def each_parameter_1(key, value, &block); end
+  end
 end
 
 Mechanize::Util::DefaultMimeTypes = T.let(T.unsafe(nil), Hash)
@@ -1114,7 +1139,7 @@ Mechanize::VERSION = T.let(T.unsafe(nil), String)
 class Mechanize::XmlFile < ::Mechanize::File
   extend(::Forwardable)
 
-  def initialize(uri = _, response = _, body = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil)); end
 
   def at(*args, &block); end
   def search(*args, &block); end
diff --git a/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi
index 27b1fb4bc6..4fca830f45 100644
--- a/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `method_source` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi b/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi
index 6b60ba30e0..0a248f7d65 100644
--- a/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `mime-types-data` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -12,9 +13,9 @@ class MIME::Types
 
   def initialize; end
 
-  def [](type_id, complete: _, registered: _); end
+  def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
   def add(*types); end
-  def add_type(type, quiet = _); end
+  def add_type(type, quiet = T.unsafe(nil)); end
   def count; end
   def each; end
   def inspect; end
@@ -29,15 +30,26 @@ class MIME::Types
   def prune_matches(matches, complete, registered); end
   def reindex_extensions!(mime_type); end
 
-  def self.[](type_id, complete: _, registered: _); end
-  def self.add(*types); end
-  def self.count; end
-  def self.each; end
-  def self.logger; end
-  def self.logger=(_); end
-  def self.new(*_); end
-  def self.of(filename); end
-  def self.type_for(filename); end
+  class << self
+    def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
+    def add(*types); end
+    def count; end
+    def each; end
+    def logger; end
+    def logger=(_); end
+    def new(*_); end
+    def of(filename); end
+    def type_for(filename); end
+
+    private
+
+    def __instances__; end
+    def __types__; end
+    def lazy_load?; end
+    def load_default_mime_types(mode = T.unsafe(nil)); end
+    def load_mode; end
+    def reindex_extensions(type); end
+  end
 end
 
 class MIME::Types::Cache < ::Struct
@@ -46,12 +58,14 @@ class MIME::Types::Cache < ::Struct
   def version; end
   def version=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.load(cache_file = _); end
-  def self.members; end
-  def self.new(*_); end
-  def self.save(types = _, cache_file = _); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def load(cache_file = T.unsafe(nil)); end
+    def members; end
+    def new(*_); end
+    def save(types = T.unsafe(nil), cache_file = T.unsafe(nil)); end
+  end
 end
 
 module MIME::Types::Data
diff --git a/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi
index b346c24567..786dd4c4e1 100644
--- a/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `mime-types` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -26,7 +27,7 @@ class MIME::Type
   def eql?(other); end
   def extensions; end
   def extensions=(value); end
-  def friendly(lang = _); end
+  def friendly(lang = T.unsafe(nil)); end
   def i18n_key; end
   def init_with(coder); end
   def inspect; end
@@ -69,9 +70,15 @@ class MIME::Type
   def xref_url_for_rfc_errata(value); end
   def xref_url_for_template(value); end
 
-  def self.i18n_key(content_type); end
-  def self.match(content_type); end
-  def self.simplified(content_type, remove_x_prefix: _); end
+  class << self
+    def i18n_key(content_type); end
+    def match(content_type); end
+    def simplified(content_type, remove_x_prefix: T.unsafe(nil)); end
+
+    private
+
+    def simplify_matchdata(matchdata, remove_x = T.unsafe(nil), joiner: T.unsafe(nil)); end
+  end
 end
 
 class MIME::Type::Columnar < ::MIME::Type
@@ -121,9 +128,9 @@ class MIME::Types
 
   def initialize; end
 
-  def [](type_id, complete: _, registered: _); end
+  def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
   def add(*types); end
-  def add_type(type, quiet = _); end
+  def add_type(type, quiet = T.unsafe(nil)); end
   def count; end
   def each; end
   def inspect; end
@@ -138,15 +145,26 @@ class MIME::Types
   def prune_matches(matches, complete, registered); end
   def reindex_extensions!(mime_type); end
 
-  def self.[](type_id, complete: _, registered: _); end
-  def self.add(*types); end
-  def self.count; end
-  def self.each; end
-  def self.logger; end
-  def self.logger=(_); end
-  def self.new(*_); end
-  def self.of(filename); end
-  def self.type_for(filename); end
+  class << self
+    def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
+    def add(*types); end
+    def count; end
+    def each; end
+    def logger; end
+    def logger=(_); end
+    def new(*_); end
+    def of(filename); end
+    def type_for(filename); end
+
+    private
+
+    def __instances__; end
+    def __types__; end
+    def lazy_load?; end
+    def load_default_mime_types(mode = T.unsafe(nil)); end
+    def load_mode; end
+    def reindex_extensions(type); end
+  end
 end
 
 class MIME::Types::Cache < ::Struct
@@ -155,12 +173,14 @@ class MIME::Types::Cache < ::Struct
   def version; end
   def version=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.load(cache_file = _); end
-  def self.members; end
-  def self.new(*_); end
-  def self.save(types = _, cache_file = _); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def load(cache_file = T.unsafe(nil)); end
+    def members; end
+    def new(*_); end
+    def save(types = T.unsafe(nil), cache_file = T.unsafe(nil)); end
+  end
 end
 
 module MIME::Types::Columnar
@@ -169,8 +189,8 @@ module MIME::Types::Columnar
   private
 
   def arr(line); end
-  def dict(line, array: _); end
-  def each_file_line(name, lookup = _); end
+  def dict(line, array: T.unsafe(nil)); end
+  def each_file_line(name, lookup = T.unsafe(nil)); end
   def flag(line); end
   def load_docs; end
   def load_encoding; end
@@ -181,7 +201,9 @@ module MIME::Types::Columnar
   def load_xrefs; end
   def opt(line); end
 
-  def self.extended(obj); end
+  class << self
+    def extended(obj); end
+  end
 end
 
 MIME::Types::Columnar::LOAD_MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
@@ -189,7 +211,7 @@ MIME::Types::Columnar::LOAD_MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
 class MIME::Types::Container
   extend(::Forwardable)
 
-  def initialize(hash = _); end
+  def initialize(hash = T.unsafe(nil)); end
 
   def ==(*args, &block); end
   def [](key); end
@@ -219,10 +241,10 @@ class MIME::Types::Container
 end
 
 class MIME::Types::Loader
-  def initialize(path = _, container = _); end
+  def initialize(path = T.unsafe(nil), container = T.unsafe(nil)); end
 
   def container; end
-  def load(options = _); end
+  def load(options = T.unsafe(nil)); end
   def load_columnar; end
   def load_json; end
   def load_yaml; end
@@ -234,15 +256,21 @@ class MIME::Types::Loader
   def json_path; end
   def yaml_path; end
 
-  def self.load(options = _); end
-  def self.load_from_json(filename); end
-  def self.load_from_yaml(filename); end
+  class << self
+    def load(options = T.unsafe(nil)); end
+    def load_from_json(filename); end
+    def load_from_yaml(filename); end
+
+    private
+
+    def read_file(filename); end
+  end
 end
 
 MIME::Types::VERSION = T.let(T.unsafe(nil), String)
 
 class MIME::Types::WarnLogger < ::Logger
-  def initialize(_one, _two = _, _three = _); end
+  def initialize(_one, _two = T.unsafe(nil), _three = T.unsafe(nil)); end
 end
 
 class MIME::Types::WarnLogger::WarnLogDevice < ::Logger::LogDevice
diff --git a/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi
index 27b1fb4bc6..9e61b4dd3a 100644
--- a/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `mini_portile2` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi b/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi
index 27b1fb4bc6..ed737fbdc6 100644
--- a/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `minitest` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi
index 27b1fb4bc6..c197d416ee 100644
--- a/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `mustache` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi
index 27b1fb4bc6..8d040b7e6e 100644
--- a/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `net-http-digest_auth` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi
index 27b1fb4bc6..e410e27643 100644
--- a/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `net-http-persistent` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.10.10.rbi b/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.10.10.rbi
index 6f16195faa..08629be645 100644
--- a/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.10.10.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.10.10.rbi
@@ -1,23 +1,28 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `nokogiri` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Nokogiri
-  def self.HTML(thing, url = _, encoding = _, options = _, &block); end
-  def self.Slop(*args, &block); end
-  def self.XML(thing, url = _, encoding = _, options = _, &block); end
-  def self.XSLT(stylesheet, modules = _); end
-  def self.install_default_aliases; end
-  def self.jruby?; end
-  def self.make(input = _, opts = _, &blk); end
-  def self.parse(string, url = _, encoding = _, options = _); end
-  def self.uses_libxml?; end
+  class << self
+    def HTML(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    def Slop(*args, &block); end
+    def XML(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    def XSLT(stylesheet, modules = T.unsafe(nil)); end
+    def install_default_aliases; end
+    def jruby?; end
+    def make(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
+    def parse(string, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    def uses_libxml?; end
+  end
 end
 
 module Nokogiri::CSS
-  def self.parse(selector); end
-  def self.xpath_for(selector, options = _); end
+  class << self
+    def parse(selector); end
+    def xpath_for(selector, options = T.unsafe(nil)); end
+  end
 end
 
 class Nokogiri::CSS::Node
@@ -27,7 +32,7 @@ class Nokogiri::CSS::Node
   def find_by_type(types); end
   def to_a; end
   def to_type; end
-  def to_xpath(prefix = _, visitor = _); end
+  def to_xpath(prefix = T.unsafe(nil), visitor = T.unsafe(nil)); end
   def type; end
   def type=(_); end
   def value; end
@@ -37,7 +42,7 @@ end
 Nokogiri::CSS::Node::ALLOW_COMBINATOR_ON_SELF = T.let(T.unsafe(nil), Array)
 
 class Nokogiri::CSS::Parser < ::Racc::Parser
-  def initialize(namespaces = _); end
+  def initialize(namespaces = T.unsafe(nil)); end
 
   def _reduce_1(val, _values, result); end
   def _reduce_11(val, _values, result); end
@@ -101,17 +106,19 @@ class Nokogiri::CSS::Parser < ::Racc::Parser
   def parse(string); end
   def unescape_css_identifier(identifier); end
   def unescape_css_string(str); end
-  def xpath_for(string, options = _); end
+  def xpath_for(string, options = T.unsafe(nil)); end
 
-  def self.[](string); end
-  def self.[]=(string, value); end
-  def self.cache_on; end
-  def self.cache_on=(_); end
-  def self.cache_on?; end
-  def self.clear_cache; end
-  def self.parse(selector); end
-  def self.set_cache(_); end
-  def self.without_cache(&block); end
+  class << self
+    def [](string); end
+    def []=(string, value); end
+    def cache_on; end
+    def cache_on=(_); end
+    def cache_on?; end
+    def clear_cache; end
+    def parse(selector); end
+    def set_cache(_); end
+    def without_cache(&block); end
+  end
 end
 
 Nokogiri::CSS::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
@@ -158,7 +165,7 @@ class Nokogiri::CSS::XPathVisitor
   private
 
   def is_of_type_pseudo_class?(node); end
-  def nth(node, options = _); end
+  def nth(node, options = T.unsafe(nil)); end
   def read_a_and_positive_b(values); end
 end
 
@@ -170,7 +177,7 @@ module Nokogiri::Decorators::Slop
 
   private
 
-  def respond_to_missing?(name, include_private = _); end
+  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
 end
 
 Nokogiri::Decorators::Slop::XPATH_PREFIX = T.let(T.unsafe(nil), String)
@@ -178,15 +185,19 @@ Nokogiri::Decorators::Slop::XPATH_PREFIX = T.let(T.unsafe(nil), String)
 class Nokogiri::EncodingHandler
   def name; end
 
-  def self.[](_); end
-  def self.alias(_, _); end
-  def self.clear_aliases!; end
-  def self.delete(_); end
+  class << self
+    def [](_); end
+    def alias(_, _); end
+    def clear_aliases!; end
+    def delete(_); end
+  end
 end
 
 module Nokogiri::HTML
-  def self.fragment(string, encoding = _); end
-  def self.parse(thing, url = _, encoding = _, options = _, &block); end
+  class << self
+    def fragment(string, encoding = T.unsafe(nil)); end
+    def parse(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  end
 end
 
 class Nokogiri::HTML::Builder < ::Nokogiri::XML::Builder
@@ -194,13 +205,13 @@ class Nokogiri::HTML::Builder < ::Nokogiri::XML::Builder
 end
 
 class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
-  def fragment(tags = _); end
+  def fragment(tags = T.unsafe(nil)); end
   def meta_encoding; end
   def meta_encoding=(encoding); end
-  def meta_robots(custom_name = _); end
-  def nofollow?(custom_name = _); end
-  def noindex?(custom_name = _); end
-  def serialize(options = _); end
+  def meta_robots(custom_name = T.unsafe(nil)); end
+  def nofollow?(custom_name = T.unsafe(nil)); end
+  def noindex?(custom_name = T.unsafe(nil)); end
+  def serialize(options = T.unsafe(nil)); end
   def title; end
   def title=(text); end
   def type; end
@@ -211,10 +222,12 @@ class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
   def parse_meta_robots(custom_name); end
   def set_metadata_element(element); end
 
-  def self.new(*_); end
-  def self.parse(string_or_io, url = _, encoding = _, options = _); end
-  def self.read_io(_, _, _, _); end
-  def self.read_memory(_, _, _, _); end
+  class << self
+    def new(*_); end
+    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    def read_io(_, _, _, _); end
+    def read_memory(_, _, _, _); end
+  end
 end
 
 class Nokogiri::HTML::Document::EncodingFound < ::StandardError
@@ -229,28 +242,32 @@ class Nokogiri::HTML::Document::EncodingReader
   def encoding_found; end
   def read(len); end
 
-  def self.detect_encoding(chunk); end
-  def self.detect_encoding_for_jruby_without_fix(chunk); end
-  def self.is_jruby_without_fix?; end
+  class << self
+    def detect_encoding(chunk); end
+    def detect_encoding_for_jruby_without_fix(chunk); end
+    def is_jruby_without_fix?; end
+  end
 end
 
 class Nokogiri::HTML::Document::EncodingReader::JumpSAXHandler < ::Nokogiri::HTML::Document::EncodingReader::SAXHandler
   def initialize(jumptag); end
 
-  def start_element(name, attrs = _); end
+  def start_element(name, attrs = T.unsafe(nil)); end
 end
 
 class Nokogiri::HTML::Document::EncodingReader::SAXHandler < ::Nokogiri::XML::SAX::Document
   def initialize; end
 
   def encoding; end
-  def start_element(name, attrs = _); end
+  def start_element(name, attrs = T.unsafe(nil)); end
 end
 
 class Nokogiri::HTML::DocumentFragment < ::Nokogiri::XML::DocumentFragment
-  def initialize(document, tags = _, ctx = _); end
+  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil)); end
 
-  def self.parse(tags, encoding = _); end
+  class << self
+    def parse(tags, encoding = T.unsafe(nil)); end
+  end
 end
 
 class Nokogiri::HTML::ElementDescription
@@ -275,7 +292,9 @@ class Nokogiri::HTML::ElementDescription
 
   def default_desc; end
 
-  def self.[](_); end
+  class << self
+    def [](_); end
+  end
 end
 
 Nokogiri::HTML::ElementDescription::ACTION_ATTR = T.let(T.unsafe(nil), Array)
@@ -510,27 +529,29 @@ module Nokogiri::HTML::SAX
 end
 
 class Nokogiri::HTML::SAX::Parser < ::Nokogiri::XML::SAX::Parser
-  def parse_file(filename, encoding = _); end
-  def parse_io(io, encoding = _); end
-  def parse_memory(data, encoding = _); end
+  def parse_file(filename, encoding = T.unsafe(nil)); end
+  def parse_io(io, encoding = T.unsafe(nil)); end
+  def parse_memory(data, encoding = T.unsafe(nil)); end
 end
 
 class Nokogiri::HTML::SAX::ParserContext < ::Nokogiri::XML::SAX::ParserContext
   def parse_with(_); end
 
-  def self.file(_, _); end
-  def self.memory(_, _); end
-  def self.new(thing, encoding = _); end
+  class << self
+    def file(_, _); end
+    def memory(_, _); end
+    def new(thing, encoding = T.unsafe(nil)); end
+  end
 end
 
 class Nokogiri::HTML::SAX::PushParser < ::Nokogiri::XML::SAX::PushParser
-  def initialize(doc = _, file_name = _, encoding = _); end
+  def initialize(doc = T.unsafe(nil), file_name = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
-  def <<(chunk, last_chunk = _); end
+  def <<(chunk, last_chunk = T.unsafe(nil)); end
   def document; end
   def document=(_); end
   def finish; end
-  def write(chunk, last_chunk = _); end
+  def write(chunk, last_chunk = T.unsafe(nil)); end
 
   private
 
@@ -573,15 +594,19 @@ class Nokogiri::VersionInfo
   def to_markdown; end
   def warnings; end
 
-  def self.instance; end
+  class << self
+    def instance; end
+  end
 end
 
 module Nokogiri::XML
-  def self.Reader(string_or_io, url = _, encoding = _, options = _); end
-  def self.RelaxNG(string_or_io); end
-  def self.Schema(string_or_io); end
-  def self.fragment(string); end
-  def self.parse(thing, url = _, encoding = _, options = _, &block); end
+  class << self
+    def Reader(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    def RelaxNG(string_or_io); end
+    def Schema(string_or_io); end
+    def fragment(string); end
+    def parse(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  end
 end
 
 class Nokogiri::XML::Attr < ::Nokogiri::XML::Node
@@ -594,7 +619,9 @@ class Nokogiri::XML::Attr < ::Nokogiri::XML::Node
 
   def inspect_attributes; end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::AttributeDecl < ::Nokogiri::XML::Node
@@ -605,7 +632,7 @@ class Nokogiri::XML::AttributeDecl < ::Nokogiri::XML::Node
 end
 
 class Nokogiri::XML::Builder
-  def initialize(options = _, root = _, &block); end
+  def initialize(options = T.unsafe(nil), root = T.unsafe(nil), &block); end
 
   def <<(string); end
   def [](ns); end
@@ -627,7 +654,9 @@ class Nokogiri::XML::Builder
 
   def insert(node, &block); end
 
-  def self.with(root, &block); end
+  class << self
+    def with(root, &block); end
+  end
 end
 
 class Nokogiri::XML::Builder::NodeBuilder
@@ -641,7 +670,9 @@ end
 class Nokogiri::XML::CDATA < ::Nokogiri::XML::Text
   def name; end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::CharacterData < ::Nokogiri::XML::Node
@@ -649,7 +680,9 @@ class Nokogiri::XML::CharacterData < ::Nokogiri::XML::Node
 end
 
 class Nokogiri::XML::Comment < ::Nokogiri::XML::CharacterData
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::DTD < ::Nokogiri::XML::Node
@@ -687,7 +720,7 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   def encoding=(_); end
   def errors; end
   def errors=(_); end
-  def fragment(tags = _); end
+  def fragment(tags = T.unsafe(nil)); end
   def name; end
   def namespaces; end
   def remove_namespaces!; end
@@ -704,12 +737,14 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
 
   def inspect_attributes; end
 
-  def self.empty_doc?(string_or_io); end
-  def self.new(*_); end
-  def self.parse(string_or_io, url = _, encoding = _, options = _); end
-  def self.read_io(_, _, _, _); end
-  def self.read_memory(_, _, _, _); end
-  def self.wrap(document); end
+  class << self
+    def empty_doc?(string_or_io); end
+    def new(*_); end
+    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    def read_io(_, _, _, _); end
+    def read_memory(_, _, _, _); end
+    def wrap(document); end
+  end
 end
 
 Nokogiri::XML::Document::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
@@ -721,7 +756,7 @@ Nokogiri::XML::Document::NCNAME_RE = T.let(T.unsafe(nil), Regexp)
 Nokogiri::XML::Document::NCNAME_START_CHAR = T.let(T.unsafe(nil), String)
 
 class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node
-  def initialize(document, tags = _, ctx = _); end
+  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil)); end
 
   def css(*args); end
   def dup; end
@@ -740,8 +775,10 @@ class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node
   def coerce(data); end
   def namespace_declarations(ctx); end
 
-  def self.new(*_); end
-  def self.parse(tags); end
+  class << self
+    def new(*_); end
+    def parse(tags); end
+  end
 end
 
 class Nokogiri::XML::Element < ::Nokogiri::XML::Node
@@ -792,7 +829,9 @@ class Nokogiri::XML::EntityDecl < ::Nokogiri::XML::Node
   def original_content; end
   def system_id; end
 
-  def self.new(name, doc, *args); end
+  class << self
+    def new(name, doc, *args); end
+  end
 end
 
 Nokogiri::XML::EntityDecl::EXTERNAL_GENERAL_PARSED = T.let(T.unsafe(nil), Integer)
@@ -811,7 +850,9 @@ class Nokogiri::XML::EntityReference < ::Nokogiri::XML::Node
   def children; end
   def inspect_attributes; end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::Namespace
@@ -847,7 +888,7 @@ class Nokogiri::XML::Node
   def add_next_sibling(node_or_tags); end
   def add_previous_sibling(node_or_tags); end
   def after(node_or_tags); end
-  def ancestors(selector = _); end
+  def ancestors(selector = T.unsafe(nil)); end
   def append_class(name); end
   def attr(name); end
   def attribute(_); end
@@ -856,7 +897,7 @@ class Nokogiri::XML::Node
   def attributes; end
   def before(node_or_tags); end
   def blank?; end
-  def canonicalize(mode = _, inclusive_namespaces = _, with_comments = _); end
+  def canonicalize(mode = T.unsafe(nil), inclusive_namespaces = T.unsafe(nil), with_comments = T.unsafe(nil)); end
   def cdata?; end
   def child; end
   def children; end
@@ -873,7 +914,7 @@ class Nokogiri::XML::Node
   def default_namespace=(url); end
   def delete(name); end
   def description; end
-  def do_xinclude(options = _); end
+  def do_xinclude(options = T.unsafe(nil)); end
   def document; end
   def document?; end
   def dup(*_); end
@@ -919,7 +960,7 @@ class Nokogiri::XML::Node
   def node_type; end
   def parent; end
   def parent=(parent_node); end
-  def parse(string_or_io, options = _); end
+  def parse(string_or_io, options = T.unsafe(nil)); end
   def path; end
   def pointer_id; end
   def prepend_child(node_or_tags); end
@@ -931,27 +972,27 @@ class Nokogiri::XML::Node
   def read_only?; end
   def remove; end
   def remove_attribute(name); end
-  def remove_class(name = _); end
+  def remove_class(name = T.unsafe(nil)); end
   def replace(node_or_tags); end
   def serialize(*args, &block); end
   def set_attribute(name, value); end
   def swap(node_or_tags); end
   def text; end
   def text?; end
-  def to_html(options = _); end
+  def to_html(options = T.unsafe(nil)); end
   def to_s; end
   def to_str; end
-  def to_xhtml(options = _); end
-  def to_xml(options = _); end
+  def to_xhtml(options = T.unsafe(nil)); end
+  def to_xml(options = T.unsafe(nil)); end
   def traverse(&block); end
   def type; end
   def unlink; end
   def values; end
   def wrap(html); end
-  def write_html_to(io, options = _); end
+  def write_html_to(io, options = T.unsafe(nil)); end
   def write_to(io, *options); end
-  def write_xhtml_to(io, options = _); end
-  def write_xml_to(io, options = _); end
+  def write_xhtml_to(io, options = T.unsafe(nil)); end
+  def write_xml_to(io, options = T.unsafe(nil)); end
   def xml?; end
 
   private
@@ -975,7 +1016,9 @@ class Nokogiri::XML::Node
   def to_format(save_option, options); end
   def write_format_to(save_option, io, options); end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 Nokogiri::XML::Node::ATTRIBUTE_DECL = T.let(T.unsafe(nil), Integer)
@@ -1017,7 +1060,7 @@ Nokogiri::XML::Node::NOTATION_NODE = T.let(T.unsafe(nil), Integer)
 Nokogiri::XML::Node::PI_NODE = T.let(T.unsafe(nil), Integer)
 
 class Nokogiri::XML::Node::SaveOptions
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def as_html; end
   def as_html?; end
@@ -1073,7 +1116,7 @@ class Nokogiri::XML::NodeSet
   include(::Nokogiri::XML::Searchable)
   include(::Enumerable)
 
-  def initialize(document, list = _); end
+  def initialize(document, list = T.unsafe(nil)); end
 
   def %(*args); end
   def &(_); end
@@ -1087,8 +1130,8 @@ class Nokogiri::XML::NodeSet
   def after(datum); end
   def append_class(name); end
   def at(*args); end
-  def attr(key, value = _, &block); end
-  def attribute(key, value = _, &block); end
+  def attr(key, value = T.unsafe(nil), &block); end
+  def attribute(key, value = T.unsafe(nil), &block); end
   def before(datum); end
   def children; end
   def clone; end
@@ -1100,9 +1143,9 @@ class Nokogiri::XML::NodeSet
   def each; end
   def empty?; end
   def filter(expr); end
-  def first(n = _); end
+  def first(n = T.unsafe(nil)); end
   def include?(_); end
-  def index(node = _); end
+  def index(node = T.unsafe(nil)); end
   def inner_html(*args); end
   def inner_text; end
   def inspect; end
@@ -1113,9 +1156,9 @@ class Nokogiri::XML::NodeSet
   def remove; end
   def remove_attr(name); end
   def remove_attribute(name); end
-  def remove_class(name = _); end
+  def remove_class(name = T.unsafe(nil)); end
   def reverse; end
-  def set(key, value = _, &block); end
+  def set(key, value = T.unsafe(nil), &block); end
   def shift; end
   def size; end
   def slice(*_); end
@@ -1151,7 +1194,7 @@ module Nokogiri::XML::PP::Node
 end
 
 class Nokogiri::XML::ParseOptions
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def compact; end
   def compact?; end
@@ -1276,13 +1319,15 @@ Nokogiri::XML::ParseOptions::XINCLUDE = T.let(T.unsafe(nil), Integer)
 class Nokogiri::XML::ProcessingInstruction < ::Nokogiri::XML::Node
   def initialize(document, name, content); end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::Reader
   include(::Enumerable)
 
-  def initialize(source, url = _, encoding = _); end
+  def initialize(source, url = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
   def attribute(_); end
   def attribute_at(_); end
@@ -1319,8 +1364,10 @@ class Nokogiri::XML::Reader
 
   def attr_nodes; end
 
-  def self.from_io(*_); end
-  def self.from_memory(*_); end
+  class << self
+    def from_io(*_); end
+    def from_memory(*_); end
+  end
 end
 
 Nokogiri::XML::Reader::TYPE_ATTRIBUTE = T.let(T.unsafe(nil), Integer)
@@ -1365,8 +1412,10 @@ class Nokogiri::XML::RelaxNG < ::Nokogiri::XML::Schema
 
   def validate_document(_); end
 
-  def self.from_document(_); end
-  def self.read_memory(_); end
+  class << self
+    def from_document(_); end
+    def read_memory(_); end
+  end
 end
 
 module Nokogiri::XML::SAX
@@ -1378,18 +1427,18 @@ class Nokogiri::XML::SAX::Document
   def comment(string); end
   def end_document; end
   def end_element(name); end
-  def end_element_namespace(name, prefix = _, uri = _); end
+  def end_element_namespace(name, prefix = T.unsafe(nil), uri = T.unsafe(nil)); end
   def error(string); end
   def processing_instruction(name, content); end
   def start_document; end
-  def start_element(name, attrs = _); end
-  def start_element_namespace(name, attrs = _, prefix = _, uri = _, ns = _); end
+  def start_element(name, attrs = T.unsafe(nil)); end
+  def start_element_namespace(name, attrs = T.unsafe(nil), prefix = T.unsafe(nil), uri = T.unsafe(nil), ns = T.unsafe(nil)); end
   def warning(string); end
   def xmldecl(version, encoding, standalone); end
 end
 
 class Nokogiri::XML::SAX::Parser
-  def initialize(doc = _, encoding = _); end
+  def initialize(doc = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
   def document; end
   def document=(_); end
@@ -1397,7 +1446,7 @@ class Nokogiri::XML::SAX::Parser
   def encoding=(_); end
   def parse(thing, &block); end
   def parse_file(filename); end
-  def parse_io(io, encoding = _); end
+  def parse_io(io, encoding = T.unsafe(nil)); end
   def parse_memory(data); end
 
   private
@@ -1419,16 +1468,18 @@ class Nokogiri::XML::SAX::ParserContext
   def replace_entities; end
   def replace_entities=(_); end
 
-  def self.file(_); end
-  def self.io(_, _); end
-  def self.memory(_); end
-  def self.new(thing, encoding = _); end
+  class << self
+    def file(_); end
+    def io(_, _); end
+    def memory(_); end
+    def new(thing, encoding = T.unsafe(nil)); end
+  end
 end
 
 class Nokogiri::XML::SAX::PushParser
-  def initialize(doc = _, file_name = _, encoding = _); end
+  def initialize(doc = T.unsafe(nil), file_name = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
-  def <<(chunk, last_chunk = _); end
+  def <<(chunk, last_chunk = T.unsafe(nil)); end
   def document; end
   def document=(_); end
   def finish; end
@@ -1436,7 +1487,7 @@ class Nokogiri::XML::SAX::PushParser
   def options=(_); end
   def replace_entities; end
   def replace_entities=(_); end
-  def write(chunk, last_chunk = _); end
+  def write(chunk, last_chunk = T.unsafe(nil)); end
 
   private
 
@@ -1455,9 +1506,11 @@ class Nokogiri::XML::Schema
   def validate_document(_); end
   def validate_file(_); end
 
-  def self.from_document(_); end
-  def self.new(string_or_io); end
-  def self.read_memory(_); end
+  class << self
+    def from_document(_); end
+    def new(string_or_io); end
+    def read_memory(_); end
+  end
 end
 
 module Nokogiri::XML::Searchable
@@ -1509,7 +1562,9 @@ end
 class Nokogiri::XML::Text < ::Nokogiri::XML::CharacterData
   def content=(string); end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 Nokogiri::XML::XML_C14N_1_0 = T.let(T.unsafe(nil), Integer)
@@ -1533,19 +1588,25 @@ class Nokogiri::XML::XPathContext
   def register_ns(_, _); end
   def register_variable(_, _); end
 
-  def self.new(_); end
+  class << self
+    def new(_); end
+  end
 end
 
 module Nokogiri::XSLT
-  def self.parse(string, modules = _); end
-  def self.quote_params(params); end
-  def self.register(_, _); end
+  class << self
+    def parse(string, modules = T.unsafe(nil)); end
+    def quote_params(params); end
+    def register(_, _); end
+  end
 end
 
 class Nokogiri::XSLT::Stylesheet
-  def apply_to(document, params = _); end
+  def apply_to(document, params = T.unsafe(nil)); end
   def serialize(_); end
   def transform(*_); end
 
-  def self.parse_stylesheet_doc(_); end
+  class << self
+    def parse_stylesheet_doc(_); end
+  end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi
index ac12411ec2..8ad5317067 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi
@@ -1,24 +1,27 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ntlm-http` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Net::NTLM
-  def self.apply_des(plain, keys); end
-  def self.decode_utf16le(str); end
-  def self.encode_utf16le(str); end
-  def self.gen_keys(str); end
-  def self.lm_hash(password); end
-  def self.lm_response(arg); end
-  def self.lmv2_response(arg, opt = _); end
-  def self.ntlm2_session(arg, opt = _); end
-  def self.ntlm_hash(password, opt = _); end
-  def self.ntlm_response(arg); end
-  def self.ntlmv2_hash(user, password, target, opt = _); end
-  def self.ntlmv2_response(arg, opt = _); end
-  def self.pack_int64le(val); end
-  def self.split7(str); end
-  def self.swap16(str); end
+  class << self
+    def apply_des(plain, keys); end
+    def decode_utf16le(str); end
+    def encode_utf16le(str); end
+    def gen_keys(str); end
+    def lm_hash(password); end
+    def lm_response(arg); end
+    def lmv2_response(arg, opt = T.unsafe(nil)); end
+    def ntlm2_session(arg, opt = T.unsafe(nil)); end
+    def ntlm_hash(password, opt = T.unsafe(nil)); end
+    def ntlm_response(arg); end
+    def ntlmv2_hash(user, password, target, opt = T.unsafe(nil)); end
+    def ntlmv2_response(arg, opt = T.unsafe(nil)); end
+    def pack_int64le(val); end
+    def split7(str); end
+    def swap16(str); end
+  end
 end
 
 class Net::NTLM::Blob < ::Net::NTLM::FieldSet
@@ -37,7 +40,9 @@ class Net::NTLM::Blob < ::Net::NTLM::FieldSet
   def unknown2; end
   def unknown2=(val); end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 class Net::NTLM::Field
@@ -57,40 +62,47 @@ class Net::NTLM::FieldSet
   def []=(name, val); end
   def disable(name); end
   def enable(name); end
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
   def size; end
 
-  def self.define(&block); end
-  def self.int16LE(name, opts); end
-  def self.int32LE(name, opts); end
-  def self.int64LE(name, opts); end
-  def self.names; end
-  def self.opts; end
-  def self.prototypes; end
-  def self.security_buffer(name, opts); end
-  def self.string(name, opts); end
-  def self.types; end
+  class << self
+    def define(&block); end
+    def int16LE(name, opts); end
+    def int32LE(name, opts); end
+    def int64LE(name, opts); end
+    def names; end
+    def opts; end
+    def prototypes; end
+    def security_buffer(name, opts); end
+    def string(name, opts); end
+    def types; end
+
+    private
+
+    def add_field(name, type, opts); end
+    def define_accessor(name); end
+  end
 end
 
 class Net::NTLM::Int16LE < ::Net::NTLM::Field
   def initialize(opt); end
 
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
 end
 
 class Net::NTLM::Int32LE < ::Net::NTLM::Field
   def initialize(opt); end
 
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
 end
 
 class Net::NTLM::Int64LE < ::Net::NTLM::Field
   def initialize(opt); end
 
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
 end
 
@@ -111,8 +123,10 @@ class Net::NTLM::Message < ::Net::NTLM::FieldSet
   def deflag; end
   def security_buffers; end
 
-  def self.decode64(str); end
-  def self.parse(str); end
+  class << self
+    def decode64(str); end
+    def parse(str); end
+  end
 end
 
 class Net::NTLM::Message::Type0 < ::Net::NTLM::Message
@@ -121,7 +135,9 @@ class Net::NTLM::Message::Type0 < ::Net::NTLM::Message
   def type; end
   def type=(val); end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 class Net::NTLM::Message::Type1 < ::Net::NTLM::Message
@@ -139,8 +155,10 @@ class Net::NTLM::Message::Type1 < ::Net::NTLM::Message
   def workstation; end
   def workstation=(val); end
 
-  def self.inherited(subclass); end
-  def self.parse(str); end
+  class << self
+    def inherited(subclass); end
+    def parse(str); end
+  end
 end
 
 class Net::NTLM::Message::Type2 < ::Net::NTLM::Message
@@ -153,7 +171,7 @@ class Net::NTLM::Message::Type2 < ::Net::NTLM::Message
   def padding; end
   def padding=(val); end
   def parse(str); end
-  def response(arg, opt = _); end
+  def response(arg, opt = T.unsafe(nil)); end
   def sign; end
   def sign=(val); end
   def target_info; end
@@ -163,8 +181,10 @@ class Net::NTLM::Message::Type2 < ::Net::NTLM::Message
   def type; end
   def type=(val); end
 
-  def self.inherited(subclass); end
-  def self.parse(str); end
+  class << self
+    def inherited(subclass); end
+    def parse(str); end
+  end
 end
 
 class Net::NTLM::Message::Type3 < ::Net::NTLM::Message
@@ -187,9 +207,11 @@ class Net::NTLM::Message::Type3 < ::Net::NTLM::Message
   def workstation; end
   def workstation=(val); end
 
-  def self.create(arg, opt = _); end
-  def self.inherited(subclass); end
-  def self.parse(str); end
+  class << self
+    def create(arg, opt = T.unsafe(nil)); end
+    def inherited(subclass); end
+    def parse(str); end
+  end
 end
 
 class Net::NTLM::SecurityBuffer < ::Net::NTLM::FieldSet
@@ -204,18 +226,20 @@ class Net::NTLM::SecurityBuffer < ::Net::NTLM::FieldSet
   def length=(val); end
   def offset; end
   def offset=(val); end
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
   def value; end
   def value=(val); end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 class Net::NTLM::String < ::Net::NTLM::Field
   def initialize(opts); end
 
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
   def value=(val); end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel@1.19.2.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel@1.19.2.rbi
index 29e0e10469..6478f47ee6 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parallel@1.19.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parallel@1.19.2.rbi
@@ -1,22 +1,40 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `parallel` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Parallel
   extend(::Parallel::ProcessorCount)
 
-  def self.all?(*args, &block); end
-  def self.any?(*args, &block); end
-  def self.each(array, options = _, &block); end
-  def self.each_with_index(array, options = _, &block); end
-  def self.flat_map(*args, &block); end
-  def self.in_processes(options = _, &block); end
-  def self.in_threads(options = _); end
-  def self.map(source, options = _, &block); end
-  def self.map_with_index(array, options = _, &block); end
-  def self.worker_number; end
-  def self.worker_number=(worker_num); end
+  class << self
+    def all?(*args, &block); end
+    def any?(*args, &block); end
+    def each(array, options = T.unsafe(nil), &block); end
+    def each_with_index(array, options = T.unsafe(nil), &block); end
+    def flat_map(*args, &block); end
+    def in_processes(options = T.unsafe(nil), &block); end
+    def in_threads(options = T.unsafe(nil)); end
+    def map(source, options = T.unsafe(nil), &block); end
+    def map_with_index(array, options = T.unsafe(nil), &block); end
+    def worker_number; end
+    def worker_number=(worker_num); end
+
+    private
+
+    def add_progress_bar!(job_factory, options); end
+    def call_with_index(item, index, options, &block); end
+    def create_workers(job_factory, options, &block); end
+    def extract_count_from_options(options); end
+    def handle_exception(exception, results); end
+    def process_incoming_jobs(read, write, job_factory, options, &block); end
+    def replace_worker(job_factory, workers, i, options, blk); end
+    def with_instrumentation(item, index, options); end
+    def work_direct(job_factory, options, &block); end
+    def work_in_processes(job_factory, options, &blk); end
+    def work_in_threads(job_factory, options, &block); end
+    def worker(job_factory, options, &block); end
+  end
 end
 
 class Parallel::Break < ::StandardError
@@ -62,8 +80,15 @@ class Parallel::UndumpableException < ::StandardError
 end
 
 class Parallel::UserInterruptHandler
-  def self.kill(thing); end
-  def self.kill_on_ctrl_c(pids, options); end
+  class << self
+    def kill(thing); end
+    def kill_on_ctrl_c(pids, options); end
+
+    private
+
+    def restore_interrupt(old, signal); end
+    def trap_interrupt(signal); end
+  end
 end
 
 Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol)
diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.1.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.1.0.rbi
index 4a2558461a..b814b40f1d 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.1.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.1.0.rbi
@@ -1,22 +1,25 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `parallel_tests` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module ParallelTests
-  def self.bundler_enabled?; end
-  def self.delta; end
-  def self.determine_number_of_processes(count); end
-  def self.first_process?; end
-  def self.last_process?; end
-  def self.now; end
-  def self.number_of_running_processes; end
-  def self.pid_file_path; end
-  def self.pids; end
-  def self.stop_all_processes; end
-  def self.wait_for_other_processes_to_finish; end
-  def self.with_pid_file; end
-  def self.with_ruby_binary(command); end
+  class << self
+    def bundler_enabled?; end
+    def delta; end
+    def determine_number_of_processes(count); end
+    def first_process?; end
+    def last_process?; end
+    def now; end
+    def number_of_running_processes; end
+    def pid_file_path; end
+    def pids; end
+    def stop_all_processes; end
+    def wait_for_other_processes_to_finish; end
+    def with_pid_file; end
+    def with_ruby_binary(command); end
+  end
 end
 
 class ParallelTests::CLI
@@ -49,9 +52,21 @@ class ParallelTests::CLI
 end
 
 class ParallelTests::Grouper
-  def self.by_scenarios(tests, num_groups, options = _); end
-  def self.by_steps(tests, num_groups, options); end
-  def self.in_even_groups_by_size(items, num_groups, options = _); end
+  class << self
+    def by_scenarios(tests, num_groups, options = T.unsafe(nil)); end
+    def by_steps(tests, num_groups, options); end
+    def in_even_groups_by_size(items, num_groups, options = T.unsafe(nil)); end
+
+    private
+
+    def add_to_group(group, item, size); end
+    def group_by_features_with_steps(tests, options); end
+    def group_by_scenarios(tests, options = T.unsafe(nil)); end
+    def group_features_by_size(items, groups_to_fill); end
+    def items_to_group(items); end
+    def largest_first(files); end
+    def smallest_group(groups); end
+  end
 end
 
 class ParallelTests::Pids
diff --git a/Library/Homebrew/sorbet/rbi/gems/parlour@4.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parlour@4.0.1.rbi
similarity index 58%
rename from Library/Homebrew/sorbet/rbi/gems/parlour@4.0.0.rbi
rename to Library/Homebrew/sorbet/rbi/gems/parlour@4.0.1.rbi
index 11091f1f37..2dd51b9823 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parlour@4.0.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parlour@4.0.1.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `parlour` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.4.rbi b/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.4.rbi
index 67b7fecda2..dcec51aa9b 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.4.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.4.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `parser` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -133,7 +134,7 @@ class Parser::AST::Processor < ::AST::Processor
 end
 
 class Parser::Base < ::Racc::Parser
-  def initialize(builder = _); end
+  def initialize(builder = T.unsafe(nil)); end
 
   def builder; end
   def context; end
@@ -147,20 +148,26 @@ class Parser::Base < ::Racc::Parser
   def reset; end
   def source_buffer; end
   def static_env; end
-  def tokenize(source_buffer, recover = _); end
+  def tokenize(source_buffer, recover = T.unsafe(nil)); end
 
   private
 
   def check_kwarg_name(name_t); end
-  def diagnostic(level, reason, arguments, location_t, highlights_ts = _); end
+  def diagnostic(level, reason, arguments, location_t, highlights_ts = T.unsafe(nil)); end
   def next_token; end
   def on_error(error_token_id, error_value, value_stack); end
 
-  def self.default_parser; end
-  def self.parse(string, file = _, line = _); end
-  def self.parse_file(filename); end
-  def self.parse_file_with_comments(filename); end
-  def self.parse_with_comments(string, file = _, line = _); end
+  class << self
+    def default_parser; end
+    def parse(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
+    def parse_file(filename); end
+    def parse_file_with_comments(filename); end
+    def parse_with_comments(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
+
+    private
+
+    def setup_source_buffer(file, line, string, encoding); end
+  end
 end
 
 module Parser::Builders
@@ -176,7 +183,7 @@ class Parser::Builders::Default
   def alias(alias_t, to, from); end
   def arg(name_t); end
   def arg_expr(expr); end
-  def args(begin_t, args, end_t, check_args = _); end
+  def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end
   def array(begin_t, elements, end_t); end
   def array_pattern(lbrack_t, elements, rbrack_t); end
   def assign(lhs, eql_t, rhs); end
@@ -185,7 +192,7 @@ class Parser::Builders::Default
   def attr_asgn(receiver, dot_t, selector_t); end
   def back_ref(token); end
   def begin(begin_t, body, end_t); end
-  def begin_body(compound_stmt, rescue_bodies = _, else_t = _, else_ = _, ensure_t = _, ensure_ = _); end
+  def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end
   def begin_keyword(begin_t, body, end_t); end
   def binary_op(receiver, operator_t, arg); end
   def block(method_call, begin_t, args, body, end_t); end
@@ -193,7 +200,7 @@ class Parser::Builders::Default
   def blockarg(amper_t, name_t); end
   def blockarg_expr(amper_t, expr); end
   def call_lambda(lambda_t); end
-  def call_method(receiver, dot_t, selector_t, lparen_t = _, args = _, rparen_t = _); end
+  def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
   def call_type_for_dot(dot_t); end
   def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
   def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
@@ -235,11 +242,11 @@ class Parser::Builders::Default
   def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
   def integer(integer_t); end
   def ivar(token); end
-  def keyword_cmd(type, keyword_t, lparen_t = _, args = _, rparen_t = _); end
+  def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
   def kwarg(name_t); end
   def kwnilarg(dstar_t, nil_t); end
   def kwoptarg(name_t, value); end
-  def kwrestarg(dstar_t, name_t = _); end
+  def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end
   def kwsplat(dstar_t, arg); end
   def logical_op(type, lhs, op_t, rhs); end
   def loop(type, keyword_t, cond, do_t, body, end_t); end
@@ -252,18 +259,18 @@ class Parser::Builders::Default
   def match_nil_pattern(dstar_t, nil_t); end
   def match_op(receiver, match_t, arg); end
   def match_pair(label_type, label, value); end
-  def match_rest(star_t, name_t = _); end
+  def match_rest(star_t, name_t = T.unsafe(nil)); end
   def match_var(name_t); end
   def match_with_trailing_comma(match, comma_t); end
   def multi_assign(lhs, eql_t, rhs); end
   def multi_lhs(begin_t, items, end_t); end
   def multi_rassign(lhs, assoc_t, rhs); end
   def nil(nil_t); end
-  def not_op(not_t, begin_t = _, receiver = _, end_t = _); end
+  def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end
   def nth_ref(token); end
   def numargs(max_numparam); end
   def objc_kwarg(kwname_t, assoc_t, name_t); end
-  def objc_restarg(star_t, name = _); end
+  def objc_restarg(star_t, name = T.unsafe(nil)); end
   def objc_varargs(pair, rest_of_varargs); end
   def op_assign(lhs, op_t, rhs); end
   def optarg(name_t, eql_t, value); end
@@ -284,11 +291,11 @@ class Parser::Builders::Default
   def regexp_compose(begin_t, parts, end_t, options); end
   def regexp_options(regopt_t); end
   def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
-  def restarg(star_t, name_t = _); end
-  def restarg_expr(star_t, expr = _); end
+  def restarg(star_t, name_t = T.unsafe(nil)); end
+  def restarg_expr(star_t, expr = T.unsafe(nil)); end
   def self(token); end
   def shadowarg(name_t); end
-  def splat(star_t, arg = _); end
+  def splat(star_t, arg = T.unsafe(nil)); end
   def string(string_t); end
   def string_compose(begin_t, parts, end_t); end
   def string_internal(string_t); end
@@ -310,13 +317,13 @@ class Parser::Builders::Default
   private
 
   def arg_name_collides?(this_name, that_name); end
-  def arg_prefix_map(op_t, name_t = _); end
+  def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end
   def binary_op_map(left_e, op_t, right_e); end
   def block_map(receiver_l, begin_t, end_t); end
   def check_assignment_to_numparam(node); end
   def check_condition(cond); end
-  def check_duplicate_arg(this_arg, map = _); end
-  def check_duplicate_args(args, map = _); end
+  def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end
+  def check_duplicate_args(args, map = T.unsafe(nil)); end
   def check_duplicate_pattern_key(name, loc); end
   def check_duplicate_pattern_variable(name, loc); end
   def check_lvar_name(name, loc); end
@@ -326,7 +333,7 @@ class Parser::Builders::Default
   def constant_map(scope, colon2_t, name_t); end
   def definition_map(keyword_t, operator_t, name_t, end_t); end
   def delimited_string_map(string_t); end
-  def diagnostic(type, reason, arguments, location, highlights = _); end
+  def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end
   def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
   def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
   def expr_map(loc); end
@@ -336,7 +343,7 @@ class Parser::Builders::Default
   def join_exprs(left_expr, right_expr); end
   def keyword_map(keyword_t, begin_t, args, end_t); end
   def keyword_mod_map(pre_e, keyword_t, post_e); end
-  def kwarg_map(name_t, value_e = _); end
+  def kwarg_map(name_t, value_e = T.unsafe(nil)); end
   def loc(token); end
   def module_definition_map(keyword_t, name_e, operator_t, end_t); end
   def n(type, children, source_map); end
@@ -350,7 +357,7 @@ class Parser::Builders::Default
   def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
   def send_binary_op_map(lhs_e, selector_t, rhs_e); end
   def send_index_map(receiver_e, lbrack_t, rbrack_t); end
-  def send_map(receiver_e, dot_t, selector_t, begin_t = _, args = _, end_t = _); end
+  def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end
   def send_unary_op_map(selector_t, arg_e); end
   def static_regexp(parts, options); end
   def static_regexp_node(node); end
@@ -359,26 +366,28 @@ class Parser::Builders::Default
   def string_value(token); end
   def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
   def token_map(token); end
-  def unary_op_map(op_t, arg_e = _); end
+  def unary_op_map(op_t, arg_e = T.unsafe(nil)); end
   def unquoted_map(token); end
   def validate_definee(definee); end
   def value(token); end
   def var_send_map(variable_e); end
   def variable_map(name_t); end
 
-  def self.emit_arg_inside_procarg0; end
-  def self.emit_arg_inside_procarg0=(_); end
-  def self.emit_encoding; end
-  def self.emit_encoding=(_); end
-  def self.emit_forward_arg; end
-  def self.emit_forward_arg=(_); end
-  def self.emit_index; end
-  def self.emit_index=(_); end
-  def self.emit_lambda; end
-  def self.emit_lambda=(_); end
-  def self.emit_procarg0; end
-  def self.emit_procarg0=(_); end
-  def self.modernize; end
+  class << self
+    def emit_arg_inside_procarg0; end
+    def emit_arg_inside_procarg0=(_); end
+    def emit_encoding; end
+    def emit_encoding=(_); end
+    def emit_forward_arg; end
+    def emit_forward_arg=(_); end
+    def emit_index; end
+    def emit_index=(_); end
+    def emit_lambda; end
+    def emit_lambda=(_); end
+    def emit_procarg0; end
+    def emit_procarg0=(_); end
+    def modernize; end
+  end
 end
 
 class Parser::ClobberingError < ::RuntimeError
@@ -418,7 +427,7 @@ module Parser::Deprecation
 end
 
 class Parser::Diagnostic
-  def initialize(level, reason, arguments, location, highlights = _); end
+  def initialize(level, reason, arguments, location, highlights = T.unsafe(nil)); end
 
   def arguments; end
   def highlights; end
@@ -432,11 +441,11 @@ class Parser::Diagnostic
 
   def first_line_only(range); end
   def last_line_only(range); end
-  def render_line(range, ellipsis = _, range_end = _); end
+  def render_line(range, ellipsis = T.unsafe(nil), range_end = T.unsafe(nil)); end
 end
 
 class Parser::Diagnostic::Engine
-  def initialize(consumer = _); end
+  def initialize(consumer = T.unsafe(nil)); end
 
   def all_errors_are_fatal; end
   def all_errors_are_fatal=(_); end
@@ -480,7 +489,7 @@ class Parser::Lexer
   def pop_cond; end
   def push_cmdarg; end
   def push_cond; end
-  def reset(reset_state = _); end
+  def reset(reset_state = T.unsafe(nil)); end
   def source_buffer; end
   def source_buffer=(source_buffer); end
   def state; end
@@ -493,74 +502,97 @@ class Parser::Lexer
   protected
 
   def arg_or_cmdarg(cmd_state); end
-  def diagnostic(type, reason, arguments = _, location = _, highlights = _); end
-  def emit(type, value = _, s = _, e = _); end
-  def emit_comment(s = _, e = _); end
-  def emit_do(do_block = _); end
-  def emit_table(table, s = _, e = _); end
+  def diagnostic(type, reason, arguments = T.unsafe(nil), location = T.unsafe(nil), highlights = T.unsafe(nil)); end
+  def emit(type, value = T.unsafe(nil), s = T.unsafe(nil), e = T.unsafe(nil)); end
+  def emit_comment(s = T.unsafe(nil), e = T.unsafe(nil)); end
+  def emit_do(do_block = T.unsafe(nil)); end
+  def emit_table(table, s = T.unsafe(nil), e = T.unsafe(nil)); end
   def encode_escape(ord); end
   def eof_codepoint?(point); end
   def literal; end
   def next_state_for_literal(literal); end
   def pop_literal; end
   def push_literal(*args); end
-  def range(s = _, e = _); end
+  def range(s = T.unsafe(nil), e = T.unsafe(nil)); end
   def stack_pop; end
-  def tok(s = _, e = _); end
+  def tok(s = T.unsafe(nil), e = T.unsafe(nil)); end
   def version?(*versions); end
 
-  def self.lex_en_expr_arg; end
-  def self.lex_en_expr_arg=(_); end
-  def self.lex_en_expr_beg; end
-  def self.lex_en_expr_beg=(_); end
-  def self.lex_en_expr_cmdarg; end
-  def self.lex_en_expr_cmdarg=(_); end
-  def self.lex_en_expr_dot; end
-  def self.lex_en_expr_dot=(_); end
-  def self.lex_en_expr_end; end
-  def self.lex_en_expr_end=(_); end
-  def self.lex_en_expr_endarg; end
-  def self.lex_en_expr_endarg=(_); end
-  def self.lex_en_expr_endfn; end
-  def self.lex_en_expr_endfn=(_); end
-  def self.lex_en_expr_fname; end
-  def self.lex_en_expr_fname=(_); end
-  def self.lex_en_expr_labelarg; end
-  def self.lex_en_expr_labelarg=(_); end
-  def self.lex_en_expr_mid; end
-  def self.lex_en_expr_mid=(_); end
-  def self.lex_en_expr_value; end
-  def self.lex_en_expr_value=(_); end
-  def self.lex_en_expr_variable; end
-  def self.lex_en_expr_variable=(_); end
-  def self.lex_en_interp_backslash_delimited; end
-  def self.lex_en_interp_backslash_delimited=(_); end
-  def self.lex_en_interp_backslash_delimited_words; end
-  def self.lex_en_interp_backslash_delimited_words=(_); end
-  def self.lex_en_interp_string; end
-  def self.lex_en_interp_string=(_); end
-  def self.lex_en_interp_words; end
-  def self.lex_en_interp_words=(_); end
-  def self.lex_en_leading_dot; end
-  def self.lex_en_leading_dot=(_); end
-  def self.lex_en_line_begin; end
-  def self.lex_en_line_begin=(_); end
-  def self.lex_en_line_comment; end
-  def self.lex_en_line_comment=(_); end
-  def self.lex_en_plain_backslash_delimited; end
-  def self.lex_en_plain_backslash_delimited=(_); end
-  def self.lex_en_plain_backslash_delimited_words; end
-  def self.lex_en_plain_backslash_delimited_words=(_); end
-  def self.lex_en_plain_string; end
-  def self.lex_en_plain_string=(_); end
-  def self.lex_en_plain_words; end
-  def self.lex_en_plain_words=(_); end
-  def self.lex_en_regexp_modifiers; end
-  def self.lex_en_regexp_modifiers=(_); end
-  def self.lex_error; end
-  def self.lex_error=(_); end
-  def self.lex_start; end
-  def self.lex_start=(_); end
+  class << self
+    def lex_en_expr_arg; end
+    def lex_en_expr_arg=(_); end
+    def lex_en_expr_beg; end
+    def lex_en_expr_beg=(_); end
+    def lex_en_expr_cmdarg; end
+    def lex_en_expr_cmdarg=(_); end
+    def lex_en_expr_dot; end
+    def lex_en_expr_dot=(_); end
+    def lex_en_expr_end; end
+    def lex_en_expr_end=(_); end
+    def lex_en_expr_endarg; end
+    def lex_en_expr_endarg=(_); end
+    def lex_en_expr_endfn; end
+    def lex_en_expr_endfn=(_); end
+    def lex_en_expr_fname; end
+    def lex_en_expr_fname=(_); end
+    def lex_en_expr_labelarg; end
+    def lex_en_expr_labelarg=(_); end
+    def lex_en_expr_mid; end
+    def lex_en_expr_mid=(_); end
+    def lex_en_expr_value; end
+    def lex_en_expr_value=(_); end
+    def lex_en_expr_variable; end
+    def lex_en_expr_variable=(_); end
+    def lex_en_interp_backslash_delimited; end
+    def lex_en_interp_backslash_delimited=(_); end
+    def lex_en_interp_backslash_delimited_words; end
+    def lex_en_interp_backslash_delimited_words=(_); end
+    def lex_en_interp_string; end
+    def lex_en_interp_string=(_); end
+    def lex_en_interp_words; end
+    def lex_en_interp_words=(_); end
+    def lex_en_leading_dot; end
+    def lex_en_leading_dot=(_); end
+    def lex_en_line_begin; end
+    def lex_en_line_begin=(_); end
+    def lex_en_line_comment; end
+    def lex_en_line_comment=(_); end
+    def lex_en_plain_backslash_delimited; end
+    def lex_en_plain_backslash_delimited=(_); end
+    def lex_en_plain_backslash_delimited_words; end
+    def lex_en_plain_backslash_delimited_words=(_); end
+    def lex_en_plain_string; end
+    def lex_en_plain_string=(_); end
+    def lex_en_plain_words; end
+    def lex_en_plain_words=(_); end
+    def lex_en_regexp_modifiers; end
+    def lex_en_regexp_modifiers=(_); end
+    def lex_error; end
+    def lex_error=(_); end
+    def lex_start; end
+    def lex_start=(_); end
+
+    private
+
+    def _lex_eof_trans; end
+    def _lex_eof_trans=(_); end
+    def _lex_from_state_actions; end
+    def _lex_from_state_actions=(_); end
+    def _lex_index_offsets; end
+    def _lex_index_offsets=(_); end
+    def _lex_indicies; end
+    def _lex_indicies=(_); end
+    def _lex_key_spans; end
+    def _lex_key_spans=(_); end
+    def _lex_to_state_actions; end
+    def _lex_to_state_actions=(_); end
+    def _lex_trans_actions; end
+    def _lex_trans_actions=(_); end
+    def _lex_trans_keys; end
+    def _lex_trans_keys=(_); end
+    def _lex_trans_targs; end
+    def _lex_trans_targs=(_); end
+  end
 end
 
 class Parser::Lexer::Dedenter
@@ -581,7 +613,7 @@ Parser::Lexer::KEYWORDS_BEGIN = T.let(T.unsafe(nil), Hash)
 Parser::Lexer::LEX_STATES = T.let(T.unsafe(nil), Hash)
 
 class Parser::Lexer::Literal
-  def initialize(lexer, str_type, delimiter, str_s, heredoc_e = _, indent = _, dedent_body = _, label_allowed = _); end
+  def initialize(lexer, str_type, delimiter, str_s, heredoc_e = T.unsafe(nil), indent = T.unsafe(nil), dedent_body = T.unsafe(nil), label_allowed = T.unsafe(nil)); end
 
   def backslash_delimited?; end
   def dedent_level; end
@@ -595,7 +627,7 @@ class Parser::Lexer::Literal
   def infer_indent_level(line); end
   def interpolate?; end
   def munge_escape?(character); end
-  def nest_and_try_closing(delimiter, ts, te, lookahead = _); end
+  def nest_and_try_closing(delimiter, ts, te, lookahead = T.unsafe(nil)); end
   def plain_heredoc?; end
   def regexp?; end
   def saved_herebody_s; end
@@ -659,7 +691,9 @@ class Parser::MaxNumparamStack
 end
 
 module Parser::Messages
-  def self.compile(reason, arguments); end
+  class << self
+    def compile(reason, arguments); end
+  end
 end
 
 module Parser::Meta
@@ -687,7 +721,7 @@ module Parser::Source
 end
 
 class Parser::Source::Buffer
-  def initialize(name, first_line = _, source: _); end
+  def initialize(name, first_line = T.unsafe(nil), source: T.unsafe(nil)); end
 
   def column_for_position(position); end
   def decompose_position(position); end
@@ -710,8 +744,10 @@ class Parser::Source::Buffer
   def line_begins; end
   def line_for(position); end
 
-  def self.recognize_encoding(string); end
-  def self.reencode_string(input); end
+  class << self
+    def recognize_encoding(string); end
+    def reencode_string(input); end
+  end
 end
 
 Parser::Source::Buffer::ENCODING_RE = T.let(T.unsafe(nil), Regexp)
@@ -728,8 +764,10 @@ class Parser::Source::Comment
   def text; end
   def type; end
 
-  def self.associate(ast, comments); end
-  def self.associate_locations(ast, comments); end
+  class << self
+    def associate(ast, comments); end
+    def associate_locations(ast, comments); end
+  end
 end
 
 class Parser::Source::Comment::Associator
@@ -913,7 +951,7 @@ class Parser::Source::Map::Ternary < ::Parser::Source::Map
 end
 
 class Parser::Source::Map::Variable < ::Parser::Source::Map
-  def initialize(name_l, expression_l = _); end
+  def initialize(name_l, expression_l = T.unsafe(nil)); end
 
   def name; end
   def operator; end
@@ -926,11 +964,12 @@ end
 
 class Parser::Source::Range
   include(::Comparable)
+  include(::RuboCop::AST::Ext::Range)
 
   def initialize(source_buffer, begin_pos, end_pos); end
 
   def <=>(other); end
-  def adjust(begin_pos: _, end_pos: _); end
+  def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
   def begin; end
   def begin_pos; end
   def column; end
@@ -962,7 +1001,7 @@ class Parser::Source::Range
   def to_a; end
   def to_range; end
   def to_s; end
-  def with(begin_pos: _, end_pos: _); end
+  def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
 end
 
 class Parser::Source::Rewriter
@@ -1012,7 +1051,7 @@ end
 class Parser::Source::Rewriter::Action
   include(::Comparable)
 
-  def initialize(range, replacement = _, allow_multiple_insertions = _, order = _); end
+  def initialize(range, replacement = T.unsafe(nil), allow_multiple_insertions = T.unsafe(nil), order = T.unsafe(nil)); end
 
   def <=>(other); end
   def allow_multiple_insertions; end
@@ -1028,13 +1067,13 @@ Parser::Source::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
 class Parser::Source::TreeRewriter
   extend(::Parser::Deprecation)
 
-  def initialize(source_buffer, crossing_deletions: _, different_replacements: _, swallowed_insertions: _); end
+  def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end
 
   def as_nested_actions; end
   def as_replacements; end
   def diagnostics; end
   def empty?; end
-  def import!(foreign_rewriter, offset: _); end
+  def import!(foreign_rewriter, offset: T.unsafe(nil)); end
   def in_transaction?; end
   def insert_after(range, content); end
   def insert_after_multi(range, text); end
@@ -1059,13 +1098,13 @@ class Parser::Source::TreeRewriter
   def check_range_validity(range); end
   def combine(range, attributes); end
   def enforce_policy(event); end
-  def trigger_policy(event, range: _, conflict: _, **arguments); end
+  def trigger_policy(event, range: T.unsafe(nil), conflict: T.unsafe(nil), **arguments); end
 end
 
 Parser::Source::TreeRewriter::ACTIONS = T.let(T.unsafe(nil), Array)
 
 class Parser::Source::TreeRewriter::Action
-  def initialize(range, enforcer, insert_before: _, replacement: _, insert_after: _, children: _); end
+  def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end
 
   def combine(action); end
   def contract; end
@@ -1082,7 +1121,7 @@ class Parser::Source::TreeRewriter::Action
   protected
 
   def analyse_hierarchy(action); end
-  def bsearch_child_index(from = _); end
+  def bsearch_child_index(from = T.unsafe(nil)); end
   def call_enforcer_for_merge(action); end
   def check_fusible(action, *fusible); end
   def children; end
@@ -1092,7 +1131,7 @@ class Parser::Source::TreeRewriter::Action
   def merge(action); end
   def place_in_hierarchy(action); end
   def swallow(children); end
-  def with(range: _, enforcer: _, children: _, insert_before: _, replacement: _, insert_after: _); end
+  def with(range: T.unsafe(nil), enforcer: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end
 end
 
 Parser::Source::TreeRewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.2.0.rbi
index 1ca16ebbef..693c30d018 100644
--- a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.2.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.2.0.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `patchelf` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi b/Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi
index c71ad6f371..b0e4e03527 100644
--- a/Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi
@@ -1,29 +1,34 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `plist` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Plist
-  def self.parse_xml(filename_or_xml); end
+  class << self
+    def parse_xml(filename_or_xml); end
+  end
 end
 
 module Plist::Emit
-  def save_plist(filename, options = _); end
-  def to_plist(envelope = _, options = _); end
+  def save_plist(filename, options = T.unsafe(nil)); end
+  def to_plist(envelope = T.unsafe(nil), options = T.unsafe(nil)); end
 
-  def self.comment(content); end
-  def self.dump(obj, envelope = _, options = _); end
-  def self.element_type(item); end
-  def self.plist_node(element, options = _); end
-  def self.save_plist(obj, filename, options = _); end
-  def self.tag(type, contents = _, options = _, &block); end
-  def self.wrap(contents); end
+  class << self
+    def comment(content); end
+    def dump(obj, envelope = T.unsafe(nil), options = T.unsafe(nil)); end
+    def element_type(item); end
+    def plist_node(element, options = T.unsafe(nil)); end
+    def save_plist(obj, filename, options = T.unsafe(nil)); end
+    def tag(type, contents = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    def wrap(contents); end
+  end
 end
 
 Plist::Emit::DEFAULT_INDENT = T.let(T.unsafe(nil), String)
 
 class Plist::Emit::IndentedString
-  def initialize(str = _); end
+  def initialize(str = T.unsafe(nil)); end
 
   def <<(val); end
   def indent_string; end
@@ -94,8 +99,10 @@ class Plist::PTag
   def text=(_); end
   def to_ruby; end
 
-  def self.inherited(sub_class); end
-  def self.mappings; end
+  class << self
+    def inherited(sub_class); end
+    def mappings; end
+  end
 end
 
 class Plist::PTrue < ::Plist::PTag
diff --git a/Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi b/Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi
index 27b1fb4bc6..666a7ad3ef 100644
--- a/Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `pry` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi
index 3a5115bbf6..68324353c2 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi
@@ -1,21 +1,26 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rainbow` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Rainbow
-  def self.enabled; end
-  def self.enabled=(value); end
-  def self.global; end
-  def self.new; end
-  def self.uncolor(string); end
+  class << self
+    def enabled; end
+    def enabled=(value); end
+    def global; end
+    def new; end
+    def uncolor(string); end
+  end
 end
 
 class Rainbow::Color
   def ground; end
 
-  def self.build(ground, values); end
-  def self.parse_hex_color(hex); end
+  class << self
+    def build(ground, values); end
+    def parse_hex_color(hex); end
+  end
 end
 
 class Rainbow::Color::Indexed < ::Rainbow::Color
@@ -28,8 +33,10 @@ end
 class Rainbow::Color::Named < ::Rainbow::Color::Indexed
   def initialize(ground, name); end
 
-  def self.color_names; end
-  def self.valid_names; end
+  class << self
+    def color_names; end
+    def valid_names; end
+  end
 end
 
 Rainbow::Color::Named::NAMES = T.let(T.unsafe(nil), Hash)
@@ -46,7 +53,9 @@ class Rainbow::Color::RGB < ::Rainbow::Color::Indexed
 
   def code_from_rgb; end
 
-  def self.to_ansi_domain(value); end
+  class << self
+    def to_ansi_domain(value); end
+  end
 end
 
 class Rainbow::Color::X11Named < ::Rainbow::Color::RGB
@@ -54,8 +63,10 @@ class Rainbow::Color::X11Named < ::Rainbow::Color::RGB
 
   def initialize(ground, name); end
 
-  def self.color_names; end
-  def self.valid_names; end
+  class << self
+    def color_names; end
+    def valid_names; end
+  end
 end
 
 class Rainbow::NullPresenter < ::String
@@ -124,12 +135,14 @@ end
 Rainbow::Presenter::TERM_EFFECTS = T.let(T.unsafe(nil), Hash)
 
 class Rainbow::StringUtils
-  def self.uncolor(string); end
-  def self.wrap_with_sgr(string, codes); end
+  class << self
+    def uncolor(string); end
+    def wrap_with_sgr(string, codes); end
+  end
 end
 
 class Rainbow::Wrapper
-  def initialize(enabled = _); end
+  def initialize(enabled = T.unsafe(nil)); end
 
   def enabled; end
   def enabled=(_); end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi
index 27b1fb4bc6..a305c3b76a 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rdiscount` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@1.7.1.rbi b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@1.7.1.rbi
index c3f1a92010..18bff78b04 100644
--- a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@1.7.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@1.7.1.rbi
@@ -1,10 +1,13 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `regexp_parser` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Regexp::Expression
-  def self.parsed(exp); end
+  class << self
+    def parsed(exp); end
+  end
 end
 
 class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
@@ -87,7 +90,7 @@ class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
 end
 
 class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def name; end
   def reference; end
@@ -97,13 +100,13 @@ class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backre
 end
 
 class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def recursion_level; end
 end
 
 class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def number; end
   def reference; end
@@ -116,7 +119,7 @@ class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expressi
 end
 
 class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::Number
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def recursion_level; end
 end
@@ -128,9 +131,9 @@ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::
 end
 
 class Regexp::Expression::Base
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
-  def =~(string, offset = _); end
+  def =~(string, offset = T.unsafe(nil)); end
   def a?; end
   def ascii_classes?; end
   def attributes; end
@@ -146,19 +149,19 @@ class Regexp::Expression::Base
   def greedy?; end
   def i?; end
   def ignore_case?; end
-  def is?(test_token, test_type = _); end
+  def is?(test_token, test_type = T.unsafe(nil)); end
   def lazy?; end
   def level; end
   def level=(_); end
   def m?; end
-  def match(string, offset = _); end
+  def match(string, offset = T.unsafe(nil)); end
   def match?(string); end
   def matches?(string); end
   def multiline?; end
   def nesting_level; end
   def nesting_level=(_); end
   def offset; end
-  def one_of?(scope, top = _); end
+  def one_of?(scope, top = T.unsafe(nil)); end
   def options; end
   def options=(_); end
   def possessive?; end
@@ -166,21 +169,21 @@ class Regexp::Expression::Base
   def quantifier; end
   def quantifier=(_); end
   def quantifier_affix(expression_format); end
-  def quantify(token, text, min = _, max = _, mode = _); end
+  def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
   def quantity; end
   def reluctant?; end
   def repetitions; end
   def set_level; end
   def set_level=(_); end
   def starts_at; end
-  def strfre(format = _, indent_offset = _, index = _); end
-  def strfregexp(format = _, indent_offset = _, index = _); end
+  def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
+  def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
   def terminal?; end
   def text; end
   def text=(_); end
   def to_h; end
-  def to_re(format = _); end
-  def to_s(format = _); end
+  def to_re(format = T.unsafe(nil)); end
+  def to_s(format = T.unsafe(nil)); end
   def token; end
   def token=(_); end
   def ts; end
@@ -199,7 +202,7 @@ class Regexp::Expression::Base
 end
 
 class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def close; end
   def closed; end
@@ -211,7 +214,7 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
   def negative; end
   def negative=(_); end
   def negative?; end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
 end
 
 class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
@@ -229,7 +232,7 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress
   def complete?; end
   def match_length; end
   def starts_at; end
-  def to_s(_format = _); end
+  def to_s(_format = T.unsafe(nil)); end
   def ts; end
 end
 
@@ -291,8 +294,8 @@ end
 
 class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
   def <<(exp); end
-  def add_sequence(active_opts = _); end
-  def branch(active_opts = _); end
+  def add_sequence(active_opts = T.unsafe(nil)); end
+  def branch(active_opts = T.unsafe(nil)); end
   def branches; end
   def condition; end
   def condition=(exp); end
@@ -300,7 +303,7 @@ class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexp
   def reference; end
   def referenced_expression; end
   def referenced_expression=(_); end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
 end
 
 class Regexp::Expression::Conditional::TooManyBranches < ::StandardError
@@ -385,7 +388,7 @@ end
 
 class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
   def match_length; end
-  def quantify(token, text, min = _, max = _, mode = _); end
+  def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
 end
 
 module Regexp::Expression::Group
@@ -401,7 +404,7 @@ end
 class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
   def capturing?; end
   def comment?; end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
 end
 
 class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
@@ -415,11 +418,11 @@ end
 
 class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
   def comment?; end
-  def to_s(_format = _); end
+  def to_s(_format = T.unsafe(nil)); end
 end
 
 class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def identifier; end
   def name; end
@@ -482,62 +485,66 @@ Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
 class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
   def initialize(*args); end
 
-  def self.build(options = _); end
-  def self.build_token; end
+  class << self
+    def build(options = T.unsafe(nil)); end
+    def build_token; end
+  end
 end
 
 class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
   def initialize(*args); end
 
-  def quantify(token, text, min = _, max = _, mode = _); end
+  def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
   def starts_at; end
   def ts; end
 
-  def self.add_to(subexpression, params = _, active_opts = _); end
-  def self.at_levels(level, set_level, conditional_level); end
+  class << self
+    def add_to(subexpression, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
+    def at_levels(level, set_level, conditional_level); end
+  end
 end
 
 class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
   def <<(exp); end
-  def add_sequence(active_opts = _); end
+  def add_sequence(active_opts = T.unsafe(nil)); end
   def operands; end
   def operator; end
   def sequences; end
   def starts_at; end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
   def ts; end
 end
 
 class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
   include(::Enumerable)
 
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def <<(exp); end
   def [](*args, &block); end
   def at(*args, &block); end
   def dig(*indices); end
   def each(*args, &block); end
-  def each_expression(include_self = _, &block); end
+  def each_expression(include_self = T.unsafe(nil), &block); end
   def empty?(*args, &block); end
   def expressions; end
   def expressions=(_); end
   def fetch(*args, &block); end
-  def flat_map(include_self = _, &block); end
+  def flat_map(include_self = T.unsafe(nil), &block); end
   def index(*args, &block); end
   def inner_match_length; end
   def join(*args, &block); end
   def last(*args, &block); end
   def length(*args, &block); end
   def match_length; end
-  def strfre_tree(format = _, include_self = _, separator = _); end
-  def strfregexp_tree(format = _, include_self = _, separator = _); end
+  def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
+  def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
   def te; end
   def to_h; end
-  def to_s(format = _); end
-  def traverse(include_self = _, &block); end
+  def to_s(format = T.unsafe(nil)); end
+  def traverse(include_self = T.unsafe(nil), &block); end
   def values_at(*args, &block); end
-  def walk(include_self = _, &block); end
+  def walk(include_self = T.unsafe(nil), &block); end
 
   private
 
@@ -787,7 +794,7 @@ class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
 end
 
 class Regexp::Lexer
-  def lex(input, syntax = _, &block); end
+  def lex(input, syntax = T.unsafe(nil), &block); end
 
   private
 
@@ -807,8 +814,10 @@ class Regexp::Lexer
   def tokens; end
   def tokens=(_); end
 
-  def self.lex(input, syntax = _, &block); end
-  def self.scan(input, syntax = _, &block); end
+  class << self
+    def lex(input, syntax = T.unsafe(nil), &block); end
+    def scan(input, syntax = T.unsafe(nil), &block); end
+  end
 end
 
 Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array)
@@ -818,9 +827,9 @@ Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
 class Regexp::MatchLength
   include(::Enumerable)
 
-  def initialize(exp, opts = _); end
+  def initialize(exp, opts = T.unsafe(nil)); end
 
-  def each(opts = _); end
+  def each(opts = T.unsafe(nil)); end
   def endless_each(&block); end
   def fixed?; end
   def include?(length); end
@@ -846,7 +855,9 @@ class Regexp::MatchLength
   def reify=(_); end
   def test_regexp; end
 
-  def self.of(obj); end
+  class << self
+    def of(obj); end
+  end
 end
 
 class Regexp::Parser
@@ -854,7 +865,7 @@ class Regexp::Parser
   include(::Regexp::Syntax)
   include(::Regexp::Expression::UnicodeProperty)
 
-  def parse(input, syntax = _, &block); end
+  def parse(input, syntax = T.unsafe(nil), &block); end
 
   private
 
@@ -909,7 +920,9 @@ class Regexp::Parser
   def type(token); end
   def update_transplanted_subtree(exp, new_parent); end
 
-  def self.parse(input, syntax = _, &block); end
+  class << self
+    def parse(input, syntax = T.unsafe(nil), &block); end
+  end
 end
 
 Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
@@ -956,14 +969,16 @@ class Regexp::Scanner
   def set_depth=(_); end
   def spacing_stack; end
   def spacing_stack=(_); end
-  def text(data, ts, te, soff = _); end
+  def text(data, ts, te, soff = T.unsafe(nil)); end
   def tokens; end
   def tokens=(_); end
   def validation_error(type, what, reason); end
 
-  def self.long_prop_map; end
-  def self.scan(input_object, &block); end
-  def self.short_prop_map; end
+  class << self
+    def long_prop_map; end
+    def scan(input_object, &block); end
+    def short_prop_map; end
+  end
 end
 
 class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
@@ -979,13 +994,13 @@ class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
 end
 
 class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
-  def initialize(what = _, where = _); end
+  def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end
 end
 
 Regexp::Scanner::PROP_MAPS_DIR = T.let(T.unsafe(nil), String)
 
 class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
-  def initialize(where = _); end
+  def initialize(where = T.unsafe(nil)); end
 end
 
 class Regexp::Scanner::ScannerError < ::StandardError
@@ -1014,16 +1029,18 @@ module Regexp::Syntax
   def version_const_name(version_string); end
   def warn_if_future_version(const_name); end
 
-  def self.comparable_version(name); end
-  def self.const_missing(const_name); end
-  def self.fallback_version_class(version); end
-  def self.inherit_from_version(parent_version, new_version); end
-  def self.new(name); end
-  def self.specified_versions; end
-  def self.supported?(name); end
-  def self.version_class(version); end
-  def self.version_const_name(version_string); end
-  def self.warn_if_future_version(const_name); end
+  class << self
+    def comparable_version(name); end
+    def const_missing(const_name); end
+    def fallback_version_class(version); end
+    def inherit_from_version(parent_version, new_version); end
+    def new(name); end
+    def specified_versions; end
+    def supported?(name); end
+    def version_class(version); end
+    def version_const_name(version_string); end
+    def warn_if_future_version(const_name); end
+  end
 end
 
 class Regexp::Syntax::Any < ::Regexp::Syntax::Base
@@ -1050,7 +1067,9 @@ class Regexp::Syntax::Base
   def normalize_backref(type, token); end
   def normalize_group(type, token); end
 
-  def self.inspect; end
+  class << self
+    def inspect; end
+  end
 end
 
 class Regexp::Syntax::InvalidVersionNameError < ::SyntaxError
@@ -1500,8 +1519,10 @@ class Regexp::Token < ::Struct
   def type; end
   def type=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi b/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi
index d01c2cbc39..fc9ca6fbbb 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rexml` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -43,7 +44,7 @@ class REXML::AttlistDecl < ::REXML::Child
   def element_name; end
   def include?(key); end
   def node_type; end
-  def write(out, indent = _); end
+  def write(out, indent = T.unsafe(nil)); end
 end
 
 class REXML::Attribute
@@ -51,7 +52,7 @@ class REXML::Attribute
   include(::REXML::XMLTokens)
   include(::REXML::Namespace)
 
-  def initialize(first, second = _, parent = _); end
+  def initialize(first, second = T.unsafe(nil), parent = T.unsafe(nil)); end
 
   def ==(other); end
   def clone; end
@@ -60,7 +61,7 @@ class REXML::Attribute
   def element=(element); end
   def hash; end
   def inspect; end
-  def namespace(arg = _); end
+  def namespace(arg = T.unsafe(nil)); end
   def node_type; end
   def normalized=(_); end
   def prefix; end
@@ -68,7 +69,7 @@ class REXML::Attribute
   def to_s; end
   def to_string; end
   def value; end
-  def write(output, indent = _); end
+  def write(output, indent = T.unsafe(nil)); end
   def xpath; end
 end
 
@@ -93,18 +94,18 @@ class REXML::Attributes < ::Hash
 end
 
 class REXML::CData < ::REXML::Text
-  def initialize(first, whitespace = _, parent = _); end
+  def initialize(first, whitespace = T.unsafe(nil), parent = T.unsafe(nil)); end
 
   def clone; end
   def to_s; end
   def value; end
-  def write(output = _, indent = _, transitive = _, ie_hack = _); end
+  def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 end
 
 class REXML::Child
   include(::REXML::Node)
 
-  def initialize(parent = _); end
+  def initialize(parent = T.unsafe(nil)); end
 
   def bytes; end
   def document; end
@@ -121,7 +122,7 @@ end
 class REXML::Comment < ::REXML::Child
   include(::Comparable)
 
-  def initialize(first, second = _); end
+  def initialize(first, second = T.unsafe(nil)); end
 
   def <=>(other); end
   def ==(other); end
@@ -130,7 +131,7 @@ class REXML::Comment < ::REXML::Child
   def string; end
   def string=(_); end
   def to_s; end
-  def write(output, indent = _, transitive = _, ie_hack = _); end
+  def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 end
 
 class REXML::Declaration < ::REXML::Child
@@ -143,7 +144,7 @@ end
 class REXML::DocType < ::REXML::Parent
   include(::REXML::XMLTokens)
 
-  def initialize(first, parent = _); end
+  def initialize(first, parent = T.unsafe(nil)); end
 
   def add(child); end
   def attribute_of(element, attribute); end
@@ -160,7 +161,7 @@ class REXML::DocType < ::REXML::Parent
   def notations; end
   def public; end
   def system; end
-  def write(output, indent = _, transitive = _, ie_hack = _); end
+  def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 
   private
 
@@ -168,11 +169,11 @@ class REXML::DocType < ::REXML::Parent
 end
 
 class REXML::Document < ::REXML::Element
-  def initialize(source = _, context = _); end
+  def initialize(source = T.unsafe(nil), context = T.unsafe(nil)); end
 
   def <<(child); end
   def add(child); end
-  def add_element(arg = _, arg2 = _); end
+  def add_element(arg = T.unsafe(nil), arg2 = T.unsafe(nil)); end
   def clone; end
   def doctype; end
   def document; end
@@ -192,26 +193,28 @@ class REXML::Document < ::REXML::Element
 
   def build(source); end
 
-  def self.entity_expansion_limit; end
-  def self.entity_expansion_limit=(val); end
-  def self.entity_expansion_text_limit; end
-  def self.entity_expansion_text_limit=(val); end
-  def self.parse_stream(source, listener); end
+  class << self
+    def entity_expansion_limit; end
+    def entity_expansion_limit=(val); end
+    def entity_expansion_text_limit; end
+    def entity_expansion_text_limit=(val); end
+    def parse_stream(source, listener); end
+  end
 end
 
 class REXML::Element < ::REXML::Parent
   include(::REXML::XMLTokens)
   include(::REXML::Namespace)
 
-  def initialize(arg = _, parent = _, context = _); end
+  def initialize(arg = T.unsafe(nil), parent = T.unsafe(nil), context = T.unsafe(nil)); end
 
   def [](name_or_index); end
-  def add_attribute(key, value = _); end
+  def add_attribute(key, value = T.unsafe(nil)); end
   def add_attributes(hash); end
-  def add_element(element, attrs = _); end
-  def add_namespace(prefix, uri = _); end
+  def add_element(element, attrs = T.unsafe(nil)); end
+  def add_namespace(prefix, uri = T.unsafe(nil)); end
   def add_text(text); end
-  def attribute(name, namespace = _); end
+  def attribute(name, namespace = T.unsafe(nil)); end
   def attributes; end
   def cdatas; end
   def clone; end
@@ -220,21 +223,21 @@ class REXML::Element < ::REXML::Parent
   def context=(_); end
   def delete_attribute(key); end
   def delete_element(element); end
-  def delete_namespace(namespace = _); end
+  def delete_namespace(namespace = T.unsafe(nil)); end
   def document; end
-  def each_element(xpath = _, &block); end
-  def each_element_with_attribute(key, value = _, max = _, name = _, &block); end
-  def each_element_with_text(text = _, max = _, name = _, &block); end
+  def each_element(xpath = T.unsafe(nil), &block); end
+  def each_element_with_attribute(key, value = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
+  def each_element_with_text(text = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
   def elements; end
   def get_elements(xpath); end
-  def get_text(path = _); end
+  def get_text(path = T.unsafe(nil)); end
   def has_attributes?; end
   def has_elements?; end
   def has_text?; end
   def ignore_whitespace_nodes; end
   def inspect; end
   def instructions; end
-  def namespace(prefix = _); end
+  def namespace(prefix = T.unsafe(nil)); end
   def namespaces; end
   def next_element; end
   def node_type; end
@@ -243,17 +246,17 @@ class REXML::Element < ::REXML::Parent
   def raw; end
   def root; end
   def root_node; end
-  def text(path = _); end
+  def text(path = T.unsafe(nil)); end
   def text=(text); end
   def texts; end
   def whitespace; end
-  def write(output = _, indent = _, transitive = _, ie_hack = _); end
+  def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
   def xpath; end
 
   private
 
   def __to_xpath_helper(node); end
-  def each_with_something(test, max = _, name = _); end
+  def each_with_something(test, max = T.unsafe(nil), name = T.unsafe(nil)); end
 end
 
 class REXML::Elements
@@ -261,19 +264,19 @@ class REXML::Elements
 
   def initialize(parent); end
 
-  def <<(element = _); end
-  def [](index, name = _); end
+  def <<(element = T.unsafe(nil)); end
+  def [](index, name = T.unsafe(nil)); end
   def []=(index, element); end
-  def add(element = _); end
-  def collect(xpath = _); end
+  def add(element = T.unsafe(nil)); end
+  def collect(xpath = T.unsafe(nil)); end
   def delete(element); end
   def delete_all(xpath); end
-  def each(xpath = _); end
+  def each(xpath = T.unsafe(nil)); end
   def empty?; end
   def index(element); end
-  def inject(xpath = _, initial = _); end
+  def inject(xpath = T.unsafe(nil), initial = T.unsafe(nil)); end
   def size; end
-  def to_a(xpath = _); end
+  def to_a(xpath = T.unsafe(nil)); end
 
   private
 
@@ -294,7 +297,7 @@ end
 class REXML::Entity < ::REXML::Child
   include(::REXML::XMLTokens)
 
-  def initialize(stream, value = _, parent = _, reference = _); end
+  def initialize(stream, value = T.unsafe(nil), parent = T.unsafe(nil), reference = T.unsafe(nil)); end
 
   def external; end
   def name; end
@@ -305,9 +308,11 @@ class REXML::Entity < ::REXML::Child
   def to_s; end
   def unnormalized; end
   def value; end
-  def write(out, indent = _); end
+  def write(out, indent = T.unsafe(nil)); end
 
-  def self.matches?(string); end
+  class << self
+    def matches?(string); end
+  end
 end
 
 class REXML::ExternalEntity < ::REXML::Child
@@ -318,7 +323,7 @@ class REXML::ExternalEntity < ::REXML::Child
 end
 
 class REXML::Formatters::Default
-  def initialize(ie_hack = _); end
+  def initialize(ie_hack = T.unsafe(nil)); end
 
   def write(node, output); end
 
@@ -333,7 +338,7 @@ class REXML::Formatters::Default
 end
 
 class REXML::Formatters::Pretty < ::REXML::Formatters::Default
-  def initialize(indentation = _, ie_hack = _); end
+  def initialize(indentation = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 
   def compact; end
   def compact=(_); end
@@ -350,20 +355,20 @@ class REXML::Formatters::Pretty < ::REXML::Formatters::Default
 
   private
 
-  def indent_text(string, level = _, style = _, indentfirstline = _); end
+  def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
   def wrap(string, width); end
 end
 
 class REXML::IOSource < ::REXML::Source
-  def initialize(arg, block_size = _, encoding = _); end
+  def initialize(arg, block_size = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
   def consume(pattern); end
   def current_line; end
   def empty?; end
-  def match(pattern, cons = _); end
+  def match(pattern, cons = T.unsafe(nil)); end
   def position; end
   def read; end
-  def scan(pattern, cons = _); end
+  def scan(pattern, cons = T.unsafe(nil)); end
 
   private
 
@@ -372,7 +377,7 @@ class REXML::IOSource < ::REXML::Source
 end
 
 class REXML::Instruction < ::REXML::Child
-  def initialize(target, content = _); end
+  def initialize(target, content = T.unsafe(nil)); end
 
   def ==(other); end
   def clone; end
@@ -382,7 +387,7 @@ class REXML::Instruction < ::REXML::Child
   def node_type; end
   def target; end
   def target=(_); end
-  def write(writer, indent = _, transitive = _, ie_hack = _); end
+  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 end
 
 class REXML::NotationDecl < ::REXML::Child
@@ -394,13 +399,13 @@ class REXML::NotationDecl < ::REXML::Child
   def system; end
   def system=(_); end
   def to_s; end
-  def write(output, indent = _); end
+  def write(output, indent = T.unsafe(nil)); end
 end
 
 class REXML::Output
   include(::REXML::Encoding)
 
-  def initialize(real_IO, encd = _); end
+  def initialize(real_IO, encd = T.unsafe(nil)); end
 
   def <<(content); end
   def encoding; end
@@ -410,7 +415,7 @@ end
 class REXML::Parent < ::REXML::Child
   include(::Enumerable)
 
-  def initialize(parent = _); end
+  def initialize(parent = T.unsafe(nil)); end
 
   def <<(object); end
   def [](index); end
@@ -437,7 +442,7 @@ class REXML::Parent < ::REXML::Child
 end
 
 class REXML::ParseException < ::RuntimeError
-  def initialize(message, source = _, parser = _, exception = _); end
+  def initialize(message, source = T.unsafe(nil), parser = T.unsafe(nil), exception = T.unsafe(nil)); end
 
   def context; end
   def continued_exception; end
@@ -458,13 +463,13 @@ class REXML::Parsers::BaseParser
   def empty?; end
   def entity(reference, entities); end
   def has_next?; end
-  def normalize(input, entities = _, entity_filter = _); end
-  def peek(depth = _); end
+  def normalize(input, entities = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
+  def peek(depth = T.unsafe(nil)); end
   def position; end
   def pull; end
   def source; end
   def stream=(source); end
-  def unnormalize(string, entities = _, filter = _); end
+  def unnormalize(string, entities = T.unsafe(nil), filter = T.unsafe(nil)); end
   def unshift(token); end
 
   private
@@ -487,7 +492,7 @@ class REXML::Parsers::StreamParser
 end
 
 class REXML::Parsers::TreeParser
-  def initialize(source, build_context = _); end
+  def initialize(source, build_context = T.unsafe(nil)); end
 
   def add_listener(listener); end
   def parse; end
@@ -532,7 +537,7 @@ REXML::Parsers::XPathParser::PREFIX_WILDCARD = T.let(T.unsafe(nil), Regexp)
 class REXML::Source
   include(::REXML::Encoding)
 
-  def initialize(arg, encoding = _); end
+  def initialize(arg, encoding = T.unsafe(nil)); end
 
   def buffer; end
   def consume(pattern); end
@@ -541,12 +546,12 @@ class REXML::Source
   def encoding; end
   def encoding=(enc); end
   def line; end
-  def match(pattern, cons = _); end
+  def match(pattern, cons = T.unsafe(nil)); end
   def match_to(char, pattern); end
   def match_to_consume(char, pattern); end
   def position; end
   def read; end
-  def scan(pattern, cons = _); end
+  def scan(pattern, cons = T.unsafe(nil)); end
 
   private
 
@@ -557,14 +562,14 @@ end
 class REXML::Text < ::REXML::Child
   include(::Comparable)
 
-  def initialize(arg, respect_whitespace = _, parent = _, raw = _, entity_filter = _, illegal = _); end
+  def initialize(arg, respect_whitespace = T.unsafe(nil), parent = T.unsafe(nil), raw = T.unsafe(nil), entity_filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
 
   def <<(to_append); end
   def <=>(other); end
   def clone; end
   def doctype; end
   def empty?; end
-  def indent_text(string, level = _, style = _, indentfirstline = _); end
+  def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
   def inspect; end
   def node_type; end
   def parent=(parent); end
@@ -573,8 +578,8 @@ class REXML::Text < ::REXML::Child
   def to_s; end
   def value; end
   def value=(val); end
-  def wrap(string, width, addnewline = _); end
-  def write(writer, indent = _, transitive = _, ie_hack = _); end
+  def wrap(string, width, addnewline = T.unsafe(nil)); end
+  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
   def write_with_substitution(out, input); end
   def xpath; end
 
@@ -582,17 +587,19 @@ class REXML::Text < ::REXML::Child
 
   def clear_cache; end
 
-  def self.check(string, pattern, doctype); end
-  def self.expand(ref, doctype, filter); end
-  def self.normalize(input, doctype = _, entity_filter = _); end
-  def self.read_with_substitution(input, illegal = _); end
-  def self.unnormalize(string, doctype = _, filter = _, illegal = _); end
+  class << self
+    def check(string, pattern, doctype); end
+    def expand(ref, doctype, filter); end
+    def normalize(input, doctype = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
+    def read_with_substitution(input, illegal = T.unsafe(nil)); end
+    def unnormalize(string, doctype = T.unsafe(nil), filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
+  end
 end
 
 class REXML::XMLDecl < ::REXML::Child
   include(::REXML::Encoding)
 
-  def initialize(version = _, encoding = _, standalone = _); end
+  def initialize(version = T.unsafe(nil), encoding = T.unsafe(nil), standalone = T.unsafe(nil)); end
 
   def ==(other); end
   def clone; end
@@ -607,7 +614,7 @@ class REXML::XMLDecl < ::REXML::Child
   def standalone=(_); end
   def version; end
   def version=(_); end
-  def write(writer, indent = _, transitive = _, ie_hack = _); end
+  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
   def writeencoding; end
   def writethis; end
   def xmldecl(version, encoding, standalone); end
@@ -616,11 +623,13 @@ class REXML::XMLDecl < ::REXML::Child
 
   def content(enc); end
 
-  def self.default; end
+  class << self
+    def default; end
+  end
 end
 
 class REXML::XPathNode
-  def initialize(node, context = _); end
+  def initialize(node, context = T.unsafe(nil)); end
 
   def context; end
   def position; end
@@ -630,16 +639,16 @@ end
 class REXML::XPathParser
   include(::REXML::XMLTokens)
 
-  def initialize(strict: _); end
+  def initialize(strict: T.unsafe(nil)); end
 
   def []=(variable_name, value); end
   def first(path_stack, node); end
   def get_first(path, nodeset); end
   def match(path_stack, nodeset); end
-  def namespaces=(namespaces = _); end
+  def namespaces=(namespaces = T.unsafe(nil)); end
   def parse(path, nodeset); end
   def predicate(path, nodeset); end
-  def variables=(vars = _); end
+  def variables=(vars = T.unsafe(nil)); end
 
   private
 
@@ -651,20 +660,20 @@ class REXML::XPathParser
   def enter(tag, *args); end
   def equality_relational_compare(set1, op, set2); end
   def evaluate_predicate(expression, nodesets); end
-  def expr(path_stack, nodeset, context = _); end
+  def expr(path_stack, nodeset, context = T.unsafe(nil)); end
   def filter_nodeset(nodeset); end
   def following(node); end
   def following_node_of(node); end
   def get_namespace(node, prefix); end
   def leave(tag, *args); end
   def next_sibling_node(node); end
-  def node_test(path_stack, nodesets, any_type: _); end
+  def node_test(path_stack, nodesets, any_type: T.unsafe(nil)); end
   def norm(b); end
   def normalize_compare_values(a, operator, b); end
   def preceding(node); end
   def preceding_node_of(node); end
   def sort(array_of_nodes, order); end
-  def step(path_stack, any_type: _, order: _); end
+  def step(path_stack, any_type: T.unsafe(nil), order: T.unsafe(nil)); end
   def strict?; end
   def trace(*args); end
   def unnode(nodeset); end
diff --git a/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi b/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi
index 27b1fb4bc6..cac8c5328c 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ronn` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.9.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.9.2.rbi
index a511fdb79d..6252469a9c 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.9.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.9.2.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-core` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -7,34 +8,40 @@ module RSpec
   extend(::RSpec::Support::Warnings)
   extend(::RSpec::Core::Warnings)
 
-  def self.clear_examples; end
-  def self.configuration; end
-  def self.configuration=(_); end
-  def self.configure; end
-  def self.const_missing(name); end
-  def self.context(*args, &example_group_block); end
-  def self.current_example; end
-  def self.current_example=(example); end
-  def self.describe(*args, &example_group_block); end
-  def self.example_group(*args, &example_group_block); end
-  def self.fcontext(*args, &example_group_block); end
-  def self.fdescribe(*args, &example_group_block); end
-  def self.reset; end
-  def self.shared_context(name, *args, &block); end
-  def self.shared_examples(name, *args, &block); end
-  def self.shared_examples_for(name, *args, &block); end
-  def self.world; end
-  def self.world=(_); end
-  def self.xcontext(*args, &example_group_block); end
-  def self.xdescribe(*args, &example_group_block); end
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
 end
 
 module RSpec::Core
-  def self.path_to_executable; end
+  class << self
+    def path_to_executable; end
+  end
 end
 
 class RSpec::Core::AnonymousExampleGroup < ::RSpec::Core::ExampleGroup
-  def self.metadata; end
+  class << self
+    def metadata; end
+  end
 end
 
 class RSpec::Core::BacktraceFormatter
@@ -45,7 +52,7 @@ class RSpec::Core::BacktraceFormatter
   def exclusion_patterns; end
   def exclusion_patterns=(_); end
   def filter_gem(gem_name); end
-  def format_backtrace(backtrace, options = _); end
+  def format_backtrace(backtrace, options = T.unsafe(nil)); end
   def full_backtrace=(_); end
   def full_backtrace?; end
   def inclusion_patterns; end
@@ -62,29 +69,29 @@ class RSpec::Core::Configuration
 
   def initialize; end
 
-  def add_formatter(formatter, output = _); end
-  def add_setting(name, opts = _); end
-  def after(scope = _, *meta, &block); end
+  def add_formatter(formatter, output = T.unsafe(nil)); end
+  def add_setting(name, opts = T.unsafe(nil)); end
+  def after(scope = T.unsafe(nil), *meta, &block); end
   def alias_example_group_to(new_name, *args); end
   def alias_example_to(name, *args); end
-  def alias_it_behaves_like_to(new_name, report_label = _); end
-  def alias_it_should_behave_like_to(new_name, report_label = _); end
-  def append_after(scope = _, *meta, &block); end
-  def append_before(scope = _, *meta, &block); end
+  def alias_it_behaves_like_to(new_name, report_label = T.unsafe(nil)); end
+  def alias_it_should_behave_like_to(new_name, report_label = T.unsafe(nil)); end
+  def append_after(scope = T.unsafe(nil), *meta, &block); end
+  def append_before(scope = T.unsafe(nil), *meta, &block); end
   def apply_derived_metadata_to(metadata); end
-  def around(scope = _, *meta, &block); end
+  def around(scope = T.unsafe(nil), *meta, &block); end
   def backtrace_exclusion_patterns; end
   def backtrace_exclusion_patterns=(patterns); end
   def backtrace_formatter; end
   def backtrace_inclusion_patterns; end
   def backtrace_inclusion_patterns=(patterns); end
-  def before(scope = _, *meta, &block); end
+  def before(scope = T.unsafe(nil), *meta, &block); end
   def bisect_runner; end
   def bisect_runner=(value); end
   def bisect_runner_class; end
   def color; end
   def color=(_); end
-  def color_enabled?(output = _); end
+  def color_enabled?(output = T.unsafe(nil)); end
   def color_mode; end
   def color_mode=(_); end
   def configure_example(example, example_hooks); end
@@ -162,7 +169,7 @@ class RSpec::Core::Configuration
   def force(hash); end
   def format_docstrings(&block); end
   def format_docstrings_block; end
-  def formatter=(formatter, output = _); end
+  def formatter=(formatter, output = T.unsafe(nil)); end
   def formatter_loader; end
   def formatters; end
   def full_backtrace=(true_or_false); end
@@ -202,8 +209,8 @@ class RSpec::Core::Configuration
   def pending_color=(_); end
   def pending_color?; end
   def prepend(mod, *filters); end
-  def prepend_after(scope = _, *meta, &block); end
-  def prepend_before(scope = _, *meta, &block); end
+  def prepend_after(scope = T.unsafe(nil), *meta, &block); end
+  def prepend_before(scope = T.unsafe(nil), *meta, &block); end
   def profile_examples; end
   def profile_examples=(_); end
   def profile_examples?; end
@@ -274,7 +281,7 @@ class RSpec::Core::Configuration
   def load_file_handling_errors(method, file); end
   def metadata_applies_to_group?(meta, group); end
   def on_existing_matching_groups(meta); end
-  def output_to_tty?(output = _); end
+  def output_to_tty?(output = T.unsafe(nil)); end
   def output_wrapper; end
   def paths_to_check(paths); end
   def pattern_might_load_specs_from_vendored_dirs?; end
@@ -287,12 +294,14 @@ class RSpec::Core::Configuration
   def update_pattern_attr(name, value); end
   def value_for(key); end
 
-  def self.add_read_only_setting(name, opts = _); end
-  def self.add_setting(name, opts = _); end
-  def self.define_aliases(name, alias_name); end
-  def self.define_predicate_for(*names); end
-  def self.define_reader(name); end
-  def self.delegate_to_ordering_manager(*methods); end
+  class << self
+    def add_read_only_setting(name, opts = T.unsafe(nil)); end
+    def add_setting(name, opts = T.unsafe(nil)); end
+    def define_aliases(name, alias_name); end
+    def define_predicate_for(*names); end
+    def define_reader(name); end
+    def delegate_to_ordering_manager(*methods); end
+  end
 end
 
 RSpec::Core::Configuration::DEFAULT_FORMATTER = T.let(T.unsafe(nil), Proc)
@@ -401,15 +410,17 @@ RSpec::Core::ConfigurationOptions::UNFORCED_OPTIONS = T.let(T.unsafe(nil), RSpec
 RSpec::Core::ConfigurationOptions::UNPROCESSABLE_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
 
 module RSpec::Core::DSL
-  def self.change_global_dsl(&changes); end
-  def self.example_group_aliases; end
-  def self.expose_example_group_alias(name); end
-  def self.expose_example_group_alias_globally(method_name); end
-  def self.expose_globally!; end
-  def self.exposed_globally?; end
-  def self.remove_globally!; end
-  def self.top_level; end
-  def self.top_level=(_); end
+  class << self
+    def change_global_dsl(&changes); end
+    def example_group_aliases; end
+    def expose_example_group_alias(name); end
+    def expose_example_group_alias_globally(method_name); end
+    def expose_globally!; end
+    def exposed_globally?; end
+    def remove_globally!; end
+    def top_level; end
+    def top_level=(_); end
+  end
 end
 
 class RSpec::Core::DeprecationError < ::StandardError
@@ -429,14 +440,14 @@ class RSpec::Core::DidYouMean
 end
 
 class RSpec::Core::Example
-  def initialize(example_group_class, description, user_metadata, example_block = _); end
+  def initialize(example_group_class, description, user_metadata, example_block = T.unsafe(nil)); end
 
   def clock; end
   def clock=(_); end
   def description; end
   def display_exception; end
   def display_exception=(ex); end
-  def duplicate_with(metadata_overrides = _); end
+  def duplicate_with(metadata_overrides = T.unsafe(nil)); end
   def example_group; end
   def example_group_instance; end
   def exception; end
@@ -480,8 +491,10 @@ class RSpec::Core::Example
   def with_around_and_singleton_context_hooks; end
   def with_around_example_hooks; end
 
-  def self.delegate_to_metadata(key); end
-  def self.parse_id(id); end
+  class << self
+    def delegate_to_metadata(key); end
+    def parse_id(id); end
+  end
 end
 
 RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
@@ -575,7 +588,7 @@ class RSpec::Core::ExampleGroup
   extend(::RSpec::Core::MemoizedHelpers::ClassMethods)
   extend(::RSpec::Core::SharedExampleGroup)
 
-  def initialize(inspect_output = _); end
+  def initialize(inspect_output = T.unsafe(nil)); end
 
   def described_class; end
   def inspect; end
@@ -584,73 +597,79 @@ class RSpec::Core::ExampleGroup
 
   def method_missing(name, *args); end
 
-  def self.add_example(example); end
-  def self.before_context_ivars; end
-  def self.children; end
-  def self.context(*args, &example_group_block); end
-  def self.currently_executing_a_context_hook?; end
-  def self.declaration_locations; end
-  def self.define_example_group_method(name, metadata = _); end
-  def self.define_example_method(name, extra_options = _); end
-  def self.define_nested_shared_group_method(new_name, report_label = _); end
-  def self.delegate_to_metadata(*names); end
-  def self.descendant_filtered_examples; end
-  def self.descendants; end
-  def self.describe(*args, &example_group_block); end
-  def self.described_class; end
-  def self.description; end
-  def self.each_instance_variable_for_example(group); end
-  def self.ensure_example_groups_are_configured; end
-  def self.example(*all_args, &block); end
-  def self.example_group(*args, &example_group_block); end
-  def self.examples; end
-  def self.fcontext(*args, &example_group_block); end
-  def self.fdescribe(*args, &example_group_block); end
-  def self.fexample(*all_args, &block); end
-  def self.file_path; end
-  def self.filtered_examples; end
-  def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
-  def self.fit(*all_args, &block); end
-  def self.focus(*all_args, &block); end
-  def self.for_filtered_examples(reporter, &block); end
-  def self.fspecify(*all_args, &block); end
-  def self.id; end
-  def self.idempotently_define_singleton_method(name, &definition); end
-  def self.include_context(name, *args, &block); end
-  def self.include_examples(name, *args, &block); end
-  def self.it(*all_args, &block); end
-  def self.it_behaves_like(name, *args, &customization_block); end
-  def self.it_should_behave_like(name, *args, &customization_block); end
-  def self.location; end
-  def self.metadata; end
-  def self.next_runnable_index_for(file); end
-  def self.ordering_strategy; end
-  def self.parent_groups; end
-  def self.pending(*all_args, &block); end
-  def self.remove_example(example); end
-  def self.reset_memoized; end
-  def self.run(reporter = _); end
-  def self.run_after_context_hooks(example_group_instance); end
-  def self.run_before_context_hooks(example_group_instance); end
-  def self.run_examples(reporter); end
-  def self.set_it_up(description, args, registration_collection, &example_group_block); end
-  def self.set_ivars(instance, ivars); end
-  def self.skip(*all_args, &block); end
-  def self.specify(*all_args, &block); end
-  def self.store_before_context_ivars(example_group_instance); end
-  def self.subclass(parent, description, args, registration_collection, &example_group_block); end
-  def self.superclass_before_context_ivars; end
-  def self.superclass_metadata; end
-  def self.top_level?; end
-  def self.top_level_description; end
-  def self.traverse_tree_until(&block); end
-  def self.update_inherited_metadata(updates); end
-  def self.with_replaced_metadata(meta); end
-  def self.xcontext(*args, &example_group_block); end
-  def self.xdescribe(*args, &example_group_block); end
-  def self.xexample(*all_args, &block); end
-  def self.xit(*all_args, &block); end
-  def self.xspecify(*all_args, &block); end
+  class << self
+    def add_example(example); end
+    def before_context_ivars; end
+    def children; end
+    def context(*args, &example_group_block); end
+    def currently_executing_a_context_hook?; end
+    def declaration_locations; end
+    def define_example_group_method(name, metadata = T.unsafe(nil)); end
+    def define_example_method(name, extra_options = T.unsafe(nil)); end
+    def define_nested_shared_group_method(new_name, report_label = T.unsafe(nil)); end
+    def delegate_to_metadata(*names); end
+    def descendant_filtered_examples; end
+    def descendants; end
+    def describe(*args, &example_group_block); end
+    def described_class; end
+    def description; end
+    def each_instance_variable_for_example(group); end
+    def ensure_example_groups_are_configured; end
+    def example(*all_args, &block); end
+    def example_group(*args, &example_group_block); end
+    def examples; end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def fexample(*all_args, &block); end
+    def file_path; end
+    def filtered_examples; end
+    def find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
+    def fit(*all_args, &block); end
+    def focus(*all_args, &block); end
+    def for_filtered_examples(reporter, &block); end
+    def fspecify(*all_args, &block); end
+    def id; end
+    def idempotently_define_singleton_method(name, &definition); end
+    def include_context(name, *args, &block); end
+    def include_examples(name, *args, &block); end
+    def it(*all_args, &block); end
+    def it_behaves_like(name, *args, &customization_block); end
+    def it_should_behave_like(name, *args, &customization_block); end
+    def location; end
+    def metadata; end
+    def next_runnable_index_for(file); end
+    def ordering_strategy; end
+    def parent_groups; end
+    def pending(*all_args, &block); end
+    def remove_example(example); end
+    def reset_memoized; end
+    def run(reporter = T.unsafe(nil)); end
+    def run_after_context_hooks(example_group_instance); end
+    def run_before_context_hooks(example_group_instance); end
+    def run_examples(reporter); end
+    def set_it_up(description, args, registration_collection, &example_group_block); end
+    def set_ivars(instance, ivars); end
+    def skip(*all_args, &block); end
+    def specify(*all_args, &block); end
+    def store_before_context_ivars(example_group_instance); end
+    def subclass(parent, description, args, registration_collection, &example_group_block); end
+    def superclass_before_context_ivars; end
+    def superclass_metadata; end
+    def top_level?; end
+    def top_level_description; end
+    def traverse_tree_until(&block); end
+    def update_inherited_metadata(updates); end
+    def with_replaced_metadata(meta); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+    def xexample(*all_args, &block); end
+    def xit(*all_args, &block); end
+    def xspecify(*all_args, &block); end
+
+    private
+
+    def method_missing(name, *args); end
+  end
 end
 
 RSpec::Core::ExampleGroup::INSTANCE_VARIABLE_TO_IGNORE = T.let(T.unsafe(nil), Symbol)
@@ -668,8 +687,10 @@ class RSpec::Core::ExampleStatusPersister
   def dump_statuses(unparsed_previous_runs); end
   def statuses_from_this_run; end
 
-  def self.load_from(file_name); end
-  def self.persist(examples, file_name); end
+  class << self
+    def load_from(file_name); end
+    def persist(examples, file_name); end
+  end
 end
 
 RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
@@ -698,7 +719,7 @@ class RSpec::Core::FilterManager
 end
 
 class RSpec::Core::FilterRules
-  def initialize(rules = _); end
+  def initialize(rules = T.unsafe(nil)); end
 
   def [](key); end
   def add(updated); end
@@ -715,7 +736,9 @@ class RSpec::Core::FilterRules
   def rules; end
   def use_only(updated); end
 
-  def self.build; end
+  class << self
+    def build; end
+  end
 end
 
 RSpec::Core::FilterRules::PROC_HEX_NUMBER = T.let(T.unsafe(nil), Regexp)
@@ -758,11 +781,15 @@ module RSpec::Core::FlatMap
 
   def flat_map(array, &block); end
 
-  def self.flat_map(array, &block); end
+  class << self
+    def flat_map(array, &block); end
+  end
 end
 
 module RSpec::Core::Formatters
-  def self.register(formatter_class, *notifications); end
+  class << self
+    def register(formatter_class, *notifications); end
+  end
 end
 
 class RSpec::Core::Formatters::BisectDRbFormatter < ::RSpec::Core::Formatters::BaseBisectFormatter
@@ -779,9 +806,11 @@ module RSpec::Core::Formatters::ConsoleCodes
   def console_code_for(code_or_symbol); end
   def wrap(text, code_or_symbol); end
 
-  def self.config_colors_to_methods; end
-  def self.console_code_for(code_or_symbol); end
-  def self.wrap(text, code_or_symbol); end
+  class << self
+    def config_colors_to_methods; end
+    def console_code_for(code_or_symbol); end
+    def wrap(text, code_or_symbol); end
+  end
 end
 
 RSpec::Core::Formatters::ConsoleCodes::VT100_CODES = T.let(T.unsafe(nil), Hash)
@@ -832,10 +861,12 @@ class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage
   def type; end
   def type=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
@@ -868,10 +899,12 @@ class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage
   def deprecation_type_for(data); end
   def output_formatted(str); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 RSpec::Core::Formatters::DeprecationFormatter::TOO_MANY_WARNINGS_NOTICE = T.let(T.unsafe(nil), String)
@@ -889,7 +922,7 @@ class RSpec::Core::Formatters::DocumentationFormatter < ::RSpec::Core::Formatter
 
   private
 
-  def current_indentation(offset = _); end
+  def current_indentation(offset = T.unsafe(nil)); end
   def failure_output(example); end
   def flush_messages; end
   def next_failure_index; end
@@ -898,16 +931,16 @@ class RSpec::Core::Formatters::DocumentationFormatter < ::RSpec::Core::Formatter
 end
 
 class RSpec::Core::Formatters::ExceptionPresenter
-  def initialize(exception, example, options = _); end
+  def initialize(exception, example, options = T.unsafe(nil)); end
 
-  def colorized_formatted_backtrace(colorizer = _); end
-  def colorized_message_lines(colorizer = _); end
+  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
+  def colorized_message_lines(colorizer = T.unsafe(nil)); end
   def description; end
   def example; end
   def exception; end
-  def formatted_backtrace(exception = _); end
+  def formatted_backtrace(exception = T.unsafe(nil)); end
   def formatted_cause(exception); end
-  def fully_formatted(failure_number, colorizer = _); end
+  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
   def fully_formatted_lines(failure_number, colorizer); end
   def message_lines; end
 
@@ -920,13 +953,13 @@ class RSpec::Core::Formatters::ExceptionPresenter
   def encoded_string(string); end
   def encoding_of(string); end
   def exception_backtrace; end
-  def exception_class_name(exception = _); end
+  def exception_class_name(exception = T.unsafe(nil)); end
   def exception_lines; end
   def extra_detail_formatter; end
   def extra_failure_lines; end
   def failure_lines; end
   def failure_slash_error_lines; end
-  def final_exception(exception, previous = _); end
+  def final_exception(exception, previous = T.unsafe(nil)); end
   def find_failed_line; end
   def formatted_message_and_backtrace(colorizer); end
   def indent_lines(lines, failure_number); end
@@ -956,7 +989,9 @@ class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTrunc
 end
 
 module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
-  def self.format_backtrace(*_); end
+  class << self
+    def format_backtrace(*_); end
+  end
 end
 
 RSpec::Core::Formatters::ExceptionPresenter::PENDING_DETAIL_FORMATTER = T.let(T.unsafe(nil), Proc)
@@ -975,10 +1010,16 @@ class RSpec::Core::Formatters::FallbackMessageFormatter
 end
 
 module RSpec::Core::Formatters::Helpers
-  def self.format_duration(duration); end
-  def self.format_seconds(float, precision = _); end
-  def self.organize_ids(ids); end
-  def self.pluralize(count, string); end
+  class << self
+    def format_duration(duration); end
+    def format_seconds(float, precision = T.unsafe(nil)); end
+    def organize_ids(ids); end
+    def pluralize(count, string); end
+
+    private
+
+    def strip_trailing_zeroes(string); end
+  end
 end
 
 RSpec::Core::Formatters::Helpers::DEFAULT_PRECISION = T.let(T.unsafe(nil), Integer)
@@ -1049,7 +1090,9 @@ class RSpec::Core::Formatters::Loader
   def underscore(camel_cased_word); end
   def underscore_with_fix_for_non_standard_rspec_naming(string); end
 
-  def self.formatters; end
+  class << self
+    def formatters; end
+  end
 end
 
 class RSpec::Core::Formatters::ProfileFormatter
@@ -1074,7 +1117,7 @@ class RSpec::Core::Formatters::ProgressFormatter < ::RSpec::Core::Formatters::Ba
 end
 
 class RSpec::Core::Formatters::SnippetExtractor
-  def initialize(source, beginning_line_number, max_line_count = _); end
+  def initialize(source, beginning_line_number, max_line_count = T.unsafe(nil)); end
 
   def beginning_line_number; end
   def expression_lines; end
@@ -1090,10 +1133,12 @@ class RSpec::Core::Formatters::SnippetExtractor
   def location_nodes_at_beginning_line; end
   def unclosed_tokens_in_line_range(line_range); end
 
-  def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count = _); end
-  def self.extract_line_at(file_path, line_number); end
-  def self.least_indentation_from(lines); end
-  def self.source_from_file(path); end
+  class << self
+    def extract_expression_lines_at(file_path, beginning_line_number, max_line_count = T.unsafe(nil)); end
+    def extract_line_at(file_path, line_number); end
+    def least_indentation_from(lines); end
+    def source_from_file(path); end
+  end
 end
 
 class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < ::StandardError
@@ -1115,17 +1160,23 @@ class RSpec::Core::Formatters::SyntaxHighlighter
   def color_enabled_implementation; end
   def implementation; end
 
-  def self.attempt_to_add_rspec_terms_to_coderay_keywords; end
+  class << self
+    def attempt_to_add_rspec_terms_to_coderay_keywords; end
+  end
 end
 
 module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
-  def self.highlight_syntax(lines); end
+  class << self
+    def highlight_syntax(lines); end
+  end
 end
 
 RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation::RESET_CODE = T.let(T.unsafe(nil), String)
 
 module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
-  def self.highlight_syntax(lines); end
+  class << self
+    def highlight_syntax(lines); end
+  end
 end
 
 RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
@@ -1259,7 +1310,9 @@ module RSpec::Core::HashImitatable
   def issue_deprecation(_method_name, *_args); end
   def set_value(name, value); end
 
-  def self.included(klass); end
+  class << self
+    def included(klass); end
+  end
 end
 
 module RSpec::Core::HashImitatable::ClassMethods
@@ -1301,10 +1354,12 @@ class RSpec::Core::Hooks::Hook < ::Struct
   def options; end
   def options=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::Hooks::HookCollections
@@ -1384,10 +1439,12 @@ class RSpec::Core::Invocations::PrintHelp < ::Struct
   def parser; end
   def parser=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::Invocations::PrintVersion
@@ -1413,8 +1470,8 @@ module RSpec::Core::MemoizedHelpers
   def initialize(*_); end
 
   def is_expected; end
-  def should(matcher = _, message = _); end
-  def should_not(matcher = _, message = _); end
+  def should(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
+  def should_not(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
   def subject; end
 
   private
@@ -1422,33 +1479,41 @@ module RSpec::Core::MemoizedHelpers
   def __init_memoized; end
   def __memoized; end
 
-  def self.define_helpers_on(example_group); end
-  def self.get_constant_or_yield(example_group, name); end
-  def self.module_for(example_group); end
+  class << self
+    def define_helpers_on(example_group); end
+    def get_constant_or_yield(example_group, name); end
+    def module_for(example_group); end
+  end
 end
 
 module RSpec::Core::MemoizedHelpers::ClassMethods
   def let(name, &block); end
   def let!(name, &block); end
-  def subject(name = _, &block); end
-  def subject!(name = _, &block); end
+  def subject(name = T.unsafe(nil), &block); end
+  def subject!(name = T.unsafe(nil), &block); end
 end
 
 class RSpec::Core::MemoizedHelpers::ContextHookMemoized
-  def self.fetch_or_store(key, &_block); end
-  def self.isolate_for_context_hook(example_group_instance); end
+  class << self
+    def fetch_or_store(key, &_block); end
+    def isolate_for_context_hook(example_group_instance); end
+  end
 end
 
 class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
-  def self.article; end
-  def self.hook_expression; end
-  def self.hook_intention; end
+  class << self
+    def article; end
+    def hook_expression; end
+    def hook_intention; end
+  end
 end
 
 class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
-  def self.article; end
-  def self.hook_expression; end
-  def self.hook_intention; end
+  class << self
+    def article; end
+    def hook_expression; end
+    def hook_intention; end
+  end
 end
 
 class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
@@ -1464,14 +1529,16 @@ class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
 end
 
 module RSpec::Core::Metadata
-  def self.ascend(metadata); end
-  def self.ascending(metadata); end
-  def self.build_hash_from(args, warn_about_example_group_filtering = _); end
-  def self.deep_hash_dup(object); end
-  def self.id_from(metadata); end
-  def self.location_tuple_from(metadata); end
-  def self.relative_path(line); end
-  def self.relative_path_regex; end
+  class << self
+    def ascend(metadata); end
+    def ascending(metadata); end
+    def build_hash_from(args, warn_about_example_group_filtering = T.unsafe(nil)); end
+    def deep_hash_dup(object); end
+    def id_from(metadata); end
+    def location_tuple_from(metadata); end
+    def relative_path(line); end
+    def relative_path_regex; end
+  end
 end
 
 class RSpec::Core::Metadata::ExampleGroupHash < ::RSpec::Core::Metadata::HashPopulator
@@ -1481,9 +1548,11 @@ class RSpec::Core::Metadata::ExampleGroupHash < ::RSpec::Core::Metadata::HashPop
   def described_class; end
   def full_description; end
 
-  def self.backwards_compatibility_default_proc(&example_group_selector); end
-  def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end
-  def self.hash_with_backwards_compatibility_default_proc; end
+  class << self
+    def backwards_compatibility_default_proc(&example_group_selector); end
+    def create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end
+    def hash_with_backwards_compatibility_default_proc; end
+  end
 end
 
 class RSpec::Core::Metadata::ExampleHash < ::RSpec::Core::Metadata::HashPopulator
@@ -1493,7 +1562,9 @@ class RSpec::Core::Metadata::ExampleHash < ::RSpec::Core::Metadata::HashPopulato
   def described_class; end
   def full_description; end
 
-  def self.create(group_metadata, user_metadata, index_provider, description, block); end
+  class << self
+    def create(group_metadata, user_metadata, index_provider, description, block); end
+  end
 end
 
 class RSpec::Core::Metadata::HashPopulator
@@ -1507,7 +1578,7 @@ class RSpec::Core::Metadata::HashPopulator
 
   private
 
-  def build_description_from(parent_description = _, my_description = _); end
+  def build_description_from(parent_description = T.unsafe(nil), my_description = T.unsafe(nil)); end
   def build_scoped_id_for(file_path); end
   def description_separator(parent_part, child_part); end
   def ensure_valid_user_keys; end
@@ -1518,9 +1589,19 @@ end
 RSpec::Core::Metadata::RESERVED_KEYS = T.let(T.unsafe(nil), Array)
 
 module RSpec::Core::MetadataFilter
-  def self.apply?(predicate, filters, metadata); end
-  def self.filter_applies?(key, filter_value, metadata); end
-  def self.silence_metadata_example_group_deprecations; end
+  class << self
+    def apply?(predicate, filters, metadata); end
+    def filter_applies?(key, filter_value, metadata); end
+    def silence_metadata_example_group_deprecations; end
+
+    private
+
+    def filter_applies_to_any_value?(key, value, metadata); end
+    def filters_apply?(key, value, metadata); end
+    def id_filter_applies?(rerun_paths_to_scoped_ids, metadata); end
+    def location_filter_applies?(locations, metadata); end
+    def proc_filter_applies?(key, proc, metadata); end
+  end
 end
 
 class RSpec::Core::MultipleExceptionError < ::StandardError
@@ -1541,14 +1622,18 @@ end
 module RSpec::Core::MultipleExceptionError::InterfaceTag
   def add(exception); end
 
-  def self.for(ex); end
+  class << self
+    def for(ex); end
+  end
 end
 
 module RSpec::Core::Notifications
 end
 
 class RSpec::Core::Notifications::CustomNotification < ::Struct
-  def self.for(options = _); end
+  class << self
+    def for(options = T.unsafe(nil)); end
+  end
 end
 
 class RSpec::Core::Notifications::DeprecationNotification < ::Struct
@@ -1561,20 +1646,32 @@ class RSpec::Core::Notifications::DeprecationNotification < ::Struct
   def replacement; end
   def replacement=(_); end
 
-  def self.[](*_); end
-  def self.from_hash(data); end
-  def self.inspect; end
-  def self.members; end
+  class << self
+    def [](*_); end
+    def from_hash(data); end
+    def inspect; end
+    def members; end
+
+    private
+
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::Notifications::ExampleNotification < ::Struct
   def example; end
   def example=(_); end
 
-  def self.[](*_); end
-  def self.for(example); end
-  def self.inspect; end
-  def self.members; end
+  class << self
+    def [](*_); end
+    def for(example); end
+    def inspect; end
+    def members; end
+
+    private
+
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::Notifications::ExamplesNotification
@@ -1583,8 +1680,8 @@ class RSpec::Core::Notifications::ExamplesNotification
   def examples; end
   def failed_examples; end
   def failure_notifications; end
-  def fully_formatted_failed_examples(colorizer = _); end
-  def fully_formatted_pending_examples(colorizer = _); end
+  def fully_formatted_failed_examples(colorizer = T.unsafe(nil)); end
+  def fully_formatted_pending_examples(colorizer = T.unsafe(nil)); end
   def notifications; end
   def pending_examples; end
   def pending_notifications; end
@@ -1595,15 +1692,15 @@ class RSpec::Core::Notifications::ExamplesNotification
 end
 
 class RSpec::Core::Notifications::FailedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
-  def initialize(example, exception_presenter = _); end
+  def initialize(example, exception_presenter = T.unsafe(nil)); end
 
-  def colorized_formatted_backtrace(colorizer = _); end
-  def colorized_message_lines(colorizer = _); end
+  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
+  def colorized_message_lines(colorizer = T.unsafe(nil)); end
   def description; end
   def exception; end
   def formatted_backtrace; end
-  def fully_formatted(failure_number, colorizer = _); end
-  def fully_formatted_lines(failure_number, colorizer = _); end
+  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
+  def fully_formatted_lines(failure_number, colorizer = T.unsafe(nil)); end
   def message_lines; end
 end
 
@@ -1611,20 +1708,24 @@ class RSpec::Core::Notifications::GroupNotification < ::Struct
   def group; end
   def group=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::Notifications::MessageNotification < ::Struct
   def message; end
   def message=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 module RSpec::Core::Notifications::NullColorizer
@@ -1633,7 +1734,9 @@ module RSpec::Core::Notifications::NullColorizer
 
   def wrap(line, _code_or_symbol); end
 
-  def self.wrap(line, _code_or_symbol); end
+  class << self
+    def wrap(line, _code_or_symbol); end
+  end
 end
 
 class RSpec::Core::Notifications::NullNotification
@@ -1672,14 +1775,16 @@ class RSpec::Core::Notifications::SeedNotification < ::Struct
 
   def used; end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::Notifications::SkippedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
-  def fully_formatted(pending_number, colorizer = _); end
+  def fully_formatted(pending_number, colorizer = T.unsafe(nil)); end
 end
 
 class RSpec::Core::Notifications::StartNotification < ::Struct
@@ -1688,17 +1793,19 @@ class RSpec::Core::Notifications::StartNotification < ::Struct
   def load_time; end
   def load_time=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::Notifications::SummaryNotification < ::Struct
   include(::RSpec::Core::ShellEscape)
 
-  def colorized_rerun_commands(colorizer = _); end
-  def colorized_totals_line(colorizer = _); end
+  def colorized_rerun_commands(colorizer = T.unsafe(nil)); end
+  def colorized_totals_line(colorizer = T.unsafe(nil)); end
   def duration; end
   def duration=(_); end
   def errors_outside_of_examples_count; end
@@ -1711,7 +1818,7 @@ class RSpec::Core::Notifications::SummaryNotification < ::Struct
   def failure_count; end
   def formatted_duration; end
   def formatted_load_time; end
-  def fully_formatted(colorizer = _); end
+  def fully_formatted(colorizer = T.unsafe(nil)); end
   def load_time; end
   def load_time=(_); end
   def pending_count; end
@@ -1724,13 +1831,21 @@ class RSpec::Core::Notifications::SummaryNotification < ::Struct
   def duplicate_rerun_locations; end
   def rerun_argument_for(example); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::NullReporter
+  class << self
+
+    private
+
+    def method_missing(*_); end
+  end
 end
 
 module RSpec::Core::Ordering
@@ -1742,7 +1857,7 @@ class RSpec::Core::Ordering::ConfigurationManager
   def force(hash); end
   def order=(type); end
   def ordering_registry; end
-  def register_ordering(name, strategy = _); end
+  def register_ordering(name, strategy = T.unsafe(nil)); end
   def seed; end
   def seed=(seed); end
   def seed_used?; end
@@ -1841,7 +1956,7 @@ class RSpec::Core::OutputWrapper
   def readlines(*args, &block); end
   def readpartial(*args, &block); end
   def reopen(*args, &block); end
-  def respond_to?(name, priv = _); end
+  def respond_to?(name, priv = T.unsafe(nil)); end
   def rewind(*args, &block); end
   def seek(*args, &block); end
   def set_encoding(*args, &block); end
@@ -1865,25 +1980,29 @@ class RSpec::Core::Parser
   def initialize(original_args); end
 
   def original_args; end
-  def parse(source = _); end
+  def parse(source = T.unsafe(nil)); end
 
   private
 
-  def add_tag_filter(options, filter_type, tag_name, value = _); end
+  def add_tag_filter(options, filter_type, tag_name, value = T.unsafe(nil)); end
   def configure_only_failures(options); end
   def parser(options); end
   def set_fail_fast(options, value); end
 
-  def self.parse(args, source = _); end
+  class << self
+    def parse(args, source = T.unsafe(nil)); end
+  end
 end
 
 module RSpec::Core::Pending
-  def pending(message = _); end
-  def skip(message = _); end
+  def pending(message = T.unsafe(nil)); end
+  def skip(message = T.unsafe(nil)); end
 
-  def self.mark_fixed!(example); end
-  def self.mark_pending!(example, message_or_bool); end
-  def self.mark_skipped!(example, message_or_bool); end
+  class << self
+    def mark_fixed!(example); end
+    def mark_pending!(example, message_or_bool); end
+    def mark_skipped!(example, message_or_bool); end
+  end
 end
 
 RSpec::Core::Pending::NOT_YET_IMPLEMENTED = T.let(T.unsafe(nil), String)
@@ -1933,11 +2052,11 @@ class RSpec::Core::Reporter
   def notify_non_example_exception(exception, context_description); end
   def pending_examples; end
   def prepare_default(loader, output_stream, deprecation_stream); end
-  def publish(event, options = _); end
+  def publish(event, options = T.unsafe(nil)); end
   def register_listener(listener, *notifications); end
   def registered_listeners(notification); end
   def report(expected_example_count); end
-  def start(expected_example_count, time = _); end
+  def start(expected_example_count, time = T.unsafe(nil)); end
   def stop; end
 
   private
@@ -1961,16 +2080,18 @@ module RSpec::Core::RubyProject
   def find_first_parent_containing(dir); end
   def root; end
 
-  def self.add_dir_to_load_path(dir); end
-  def self.add_to_load_path(*dirs); end
-  def self.ascend_until; end
-  def self.determine_root; end
-  def self.find_first_parent_containing(dir); end
-  def self.root; end
+  class << self
+    def add_dir_to_load_path(dir); end
+    def add_to_load_path(*dirs); end
+    def ascend_until; end
+    def determine_root; end
+    def find_first_parent_containing(dir); end
+    def root; end
+  end
 end
 
 class RSpec::Core::Runner
-  def initialize(options, configuration = _, world = _); end
+  def initialize(options, configuration = T.unsafe(nil), world = T.unsafe(nil)); end
 
   def configuration; end
   def configure(err, out); end
@@ -1984,22 +2105,24 @@ class RSpec::Core::Runner
 
   def persist_example_statuses; end
 
-  def self.autorun; end
-  def self.autorun_disabled?; end
-  def self.disable_autorun!; end
-  def self.handle_interrupt; end
-  def self.installed_at_exit?; end
-  def self.invoke; end
-  def self.perform_at_exit; end
-  def self.run(args, err = _, out = _); end
-  def self.running_in_drb?; end
-  def self.trap_interrupt; end
+  class << self
+    def autorun; end
+    def autorun_disabled?; end
+    def disable_autorun!; end
+    def handle_interrupt; end
+    def installed_at_exit?; end
+    def invoke; end
+    def perform_at_exit; end
+    def run(args, err = T.unsafe(nil), out = T.unsafe(nil)); end
+    def running_in_drb?; end
+    def trap_interrupt; end
+  end
 end
 
 class RSpec::Core::Set
   include(::Enumerable)
 
-  def initialize(array = _); end
+  def initialize(array = T.unsafe(nil)); end
 
   def <<(key); end
   def clear; end
@@ -2010,42 +2133,6 @@ class RSpec::Core::Set
   def merge(values); end
 end
 
-module RSpec::Core::SharedContext
-  def __shared_context_recordings; end
-  def after(*args, &block); end
-  def append_after(*args, &block); end
-  def append_before(*args, &block); end
-  def around(*args, &block); end
-  def before(*args, &block); end
-  def context(*args, &block); end
-  def describe(*args, &block); end
-  def hooks(*args, &block); end
-  def included(group); end
-  def let(*args, &block); end
-  def let!(*args, &block); end
-  def prepend_after(*args, &block); end
-  def prepend_before(*args, &block); end
-  def subject(*args, &block); end
-  def subject!(*args, &block); end
-
-  def self.record(methods); end
-end
-
-class RSpec::Core::SharedContext::Recording < ::Struct
-  def args; end
-  def args=(_); end
-  def block; end
-  def block=(_); end
-  def method_name; end
-  def method_name=(_); end
-  def playback_onto(group); end
-
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
-end
-
 module RSpec::Core::SharedExampleGroup
   def shared_context(name, *args, &block); end
   def shared_examples(name, *args, &block); end
@@ -2067,10 +2154,12 @@ class RSpec::Core::SharedExampleGroup::Registry
 end
 
 module RSpec::Core::SharedExampleGroup::TopLevelDSL
-  def self.definitions; end
-  def self.expose_globally!; end
-  def self.exposed_globally?; end
-  def self.remove_globally!; end
+  class << self
+    def definitions; end
+    def expose_globally!; end
+    def exposed_globally?; end
+    def remove_globally!; end
+  end
 end
 
 class RSpec::Core::SharedExampleGroupInclusionStackFrame
@@ -2081,9 +2170,11 @@ class RSpec::Core::SharedExampleGroupInclusionStackFrame
   def inclusion_location; end
   def shared_group_name; end
 
-  def self.current_backtrace; end
-  def self.shared_example_group_inclusions; end
-  def self.with_frame(name, location); end
+  class << self
+    def current_backtrace; end
+    def shared_example_group_inclusions; end
+    def with_frame(name, location); end
+  end
 end
 
 class RSpec::Core::SharedExampleGroupModule < ::Module
@@ -2105,10 +2196,12 @@ module RSpec::Core::ShellEscape
   def quote(argument); end
   def shell_allows_unquoted_ids?; end
 
-  def self.conditionally_quote(id); end
-  def self.escape(shell_command); end
-  def self.quote(argument); end
-  def self.shell_allows_unquoted_ids?; end
+  class << self
+    def conditionally_quote(id); end
+    def escape(shell_command); end
+    def quote(argument); end
+    def shell_allows_unquoted_ids?; end
+  end
 end
 
 RSpec::Core::ShellEscape::SHELLS_ALLOWING_UNQUOTED_IDS = T.let(T.unsafe(nil), Array)
@@ -2120,7 +2213,9 @@ class RSpec::Core::SuiteHookContext < ::RSpec::Core::Example
 end
 
 class RSpec::Core::Time
-  def self.now; end
+  class << self
+    def now; end
+  end
 end
 
 module RSpec::Core::Version
@@ -2129,13 +2224,13 @@ end
 RSpec::Core::Version::STRING = T.let(T.unsafe(nil), String)
 
 module RSpec::Core::Warnings
-  def deprecate(deprecated, data = _); end
-  def warn_deprecation(message, opts = _); end
-  def warn_with(message, options = _); end
+  def deprecate(deprecated, data = T.unsafe(nil)); end
+  def warn_deprecation(message, opts = T.unsafe(nil)); end
+  def warn_with(message, options = T.unsafe(nil)); end
 end
 
 class RSpec::Core::World
-  def initialize(configuration = _); end
+  def initialize(configuration = T.unsafe(nil)); end
 
   def all_example_groups; end
   def all_examples; end
@@ -2143,7 +2238,7 @@ class RSpec::Core::World
   def announce_filters; end
   def announce_inclusion_filter(announcements); end
   def everything_filtered_message; end
-  def example_count(groups = _); end
+  def example_count(groups = T.unsafe(nil)); end
   def example_group_counts_by_spec_file; end
   def example_groups; end
   def exclusion_filter; end
@@ -2175,22 +2270,26 @@ class RSpec::Core::World
 end
 
 module RSpec::Core::World::Null
-  def self.all_example_groups; end
-  def self.example_groups; end
-  def self.non_example_failure; end
-  def self.non_example_failure=(_); end
-  def self.registered_example_group_files; end
-  def self.traverse_example_group_trees_until; end
+  class << self
+    def all_example_groups; end
+    def example_groups; end
+    def non_example_failure; end
+    def non_example_failure=(_); end
+    def registered_example_group_files; end
+    def traverse_example_group_trees_until; end
+  end
 end
 
 module RSpec::ExampleGroups
   extend(::RSpec::Support::RecursiveConstMethods)
 
-  def self.assign_const(group); end
-  def self.base_name_for(group); end
-  def self.constant_scope_for(group); end
-  def self.disambiguate(name, const_scope); end
-  def self.remove_all_constants; end
+  class << self
+    def assign_const(group); end
+    def base_name_for(group); end
+    def constant_scope_for(group); end
+    def disambiguate(name, const_scope); end
+    def remove_all_constants; end
+  end
 end
 
 RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
@@ -2201,7 +2300,9 @@ module RSpec::Core::Bisect
 end
 
 class RSpec::Core::Bisect::BisectFailedError < ::StandardError
-  def self.for_failed_spec_run(spec_output); end
+  class << self
+    def for_failed_spec_run(spec_output); end
+  end
 end
 
 class RSpec::Core::Bisect::Channel
@@ -2218,10 +2319,12 @@ class RSpec::Core::Bisect::ExampleSetDescriptor < ::Struct
   def failed_example_ids; end
   def failed_example_ids=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Core::Bisect::Notifier
@@ -2244,7 +2347,9 @@ class RSpec::Core::ExampleStatusDumper
   def headers; end
   def rows; end
 
-  def self.dump(examples); end
+  class << self
+    def dump(examples); end
+  end
 end
 
 class RSpec::Core::ExampleStatusMerger
@@ -2261,7 +2366,9 @@ class RSpec::Core::ExampleStatusMerger
   def sort_value_from(example); end
   def spec_file_from(ex_id); end
 
-  def self.merge(this_run, from_previous_runs); end
+  class << self
+    def merge(this_run, from_previous_runs); end
+  end
 end
 
 class RSpec::Core::ExampleStatusParser
@@ -2275,7 +2382,9 @@ class RSpec::Core::ExampleStatusParser
   def parse_row(line); end
   def split_line(line); end
 
-  def self.parse(string); end
+  class << self
+    def parse(string); end
+  end
 end
 
 class RSpec::Core::Formatters::BaseBisectFormatter
@@ -2285,7 +2394,9 @@ class RSpec::Core::Formatters::BaseBisectFormatter
   def example_finished(notification); end
   def start_dump(_notification); end
 
-  def self.inherited(formatter); end
+  class << self
+    def inherited(formatter); end
+  end
 end
 
 class RSpec::Core::Formatters::BaseFormatter
@@ -2345,3 +2456,43 @@ RSpec::Core::Formatters::HtmlPrinter::GLOBAL_STYLES = T.let(T.unsafe(nil), Strin
 RSpec::Core::Formatters::HtmlPrinter::HTML_HEADER = T.let(T.unsafe(nil), String)
 
 RSpec::Core::Formatters::HtmlPrinter::REPORT_HEADER = T.let(T.unsafe(nil), String)
+
+module RSpec::Core::SharedContext
+  def __shared_context_recordings; end
+  def after(*args, &block); end
+  def append_after(*args, &block); end
+  def append_before(*args, &block); end
+  def around(*args, &block); end
+  def before(*args, &block); end
+  def context(*args, &block); end
+  def describe(*args, &block); end
+  def hooks(*args, &block); end
+  def included(group); end
+  def let(*args, &block); end
+  def let!(*args, &block); end
+  def prepend_after(*args, &block); end
+  def prepend_before(*args, &block); end
+  def subject(*args, &block); end
+  def subject!(*args, &block); end
+
+  class << self
+    def record(methods); end
+  end
+end
+
+class RSpec::Core::SharedContext::Recording < ::Struct
+  def args; end
+  def args=(_); end
+  def block; end
+  def block=(_); end
+  def method_name; end
+  def method_name=(_); end
+  def playback_onto(group); end
+
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.9.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.9.2.rbi
index b1aed5dc1c..cec4824ec0 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.9.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.9.2.rbi
@@ -1,18 +1,21 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-expectations` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module RSpec::Expectations
-  def self.configuration; end
-  def self.differ; end
-  def self.fail_with(message, expected = _, actual = _); end
+  class << self
+    def configuration; end
+    def differ; end
+    def fail_with(message, expected = T.unsafe(nil), actual = T.unsafe(nil)); end
+  end
 end
 
 class RSpec::Expectations::BlockExpectationTarget < ::RSpec::Expectations::ExpectationTarget
-  def not_to(matcher, message = _, &block); end
-  def to(matcher, message = _, &block); end
-  def to_not(matcher, message = _, &block); end
+  def not_to(matcher, message = T.unsafe(nil), &block); end
+  def to(matcher, message = T.unsafe(nil), &block); end
+  def to_not(matcher, message = T.unsafe(nil), &block); end
 
   private
 
@@ -37,7 +40,9 @@ class RSpec::Expectations::BlockSnippetExtractor
   def source; end
   def source_location; end
 
-  def self.try_extracting_single_line_body_of(proc, method_name); end
+  class << self
+    def try_extracting_single_line_body_of(proc, method_name); end
+  end
 end
 
 class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error
@@ -62,10 +67,12 @@ class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct
   def method_ident_node; end
   def method_ident_node?(node); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct
@@ -101,10 +108,12 @@ class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct
   def pending_tokens; end
   def pipe_token?(token); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError
@@ -136,14 +145,18 @@ end
 RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash)
 
 module RSpec::Expectations::Configuration::NullBacktraceFormatter
-  def self.format_backtrace(backtrace); end
+  class << self
+    def format_backtrace(backtrace); end
+  end
 end
 
 module RSpec::Expectations::ExpectationHelper
-  def self.check_message(msg); end
-  def self.handle_failure(matcher, message, failure_message_method); end
-  def self.modern_matcher_from(matcher); end
-  def self.with_matcher(handler, matcher, message); end
+  class << self
+    def check_message(msg); end
+    def handle_failure(matcher, message, failure_message_method); end
+    def modern_matcher_from(matcher); end
+    def with_matcher(handler, matcher, message); end
+  end
 end
 
 class RSpec::Expectations::ExpectationNotMetError < ::Exception
@@ -156,13 +169,15 @@ class RSpec::Expectations::ExpectationTarget
 
   def target; end
 
-  def self.for(value, block); end
+  class << self
+    def for(value, block); end
+  end
 end
 
 module RSpec::Expectations::ExpectationTarget::InstanceMethods
-  def not_to(matcher = _, message = _, &block); end
-  def to(matcher = _, message = _, &block); end
-  def to_not(matcher = _, message = _, &block); end
+  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
 
   private
 
@@ -193,21 +208,27 @@ RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAda
 class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator
   def initialize(matcher); end
 
-  def self.wrap(matcher); end
+  class << self
+    def wrap(matcher); end
+  end
 end
 
 class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter
   def failure_message; end
   def failure_message_when_negated; end
 
-  def self.interface_matches?(matcher); end
+  class << self
+    def interface_matches?(matcher); end
+  end
 end
 
 class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter
   def failure_message; end
   def failure_message_when_negated; end
 
-  def self.interface_matches?(matcher); end
+  class << self
+    def interface_matches?(matcher); end
+  end
 end
 
 class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError
@@ -237,18 +258,22 @@ class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectatio
 end
 
 class RSpec::Expectations::NegativeExpectationHandler
-  def self.does_not_match?(matcher, actual, &block); end
-  def self.handle_matcher(actual, initial_matcher, message = _, &block); end
-  def self.opposite_should_method; end
-  def self.should_method; end
-  def self.verb; end
+  class << self
+    def does_not_match?(matcher, actual, &block); end
+    def handle_matcher(actual, initial_matcher, message = T.unsafe(nil), &block); end
+    def opposite_should_method; end
+    def should_method; end
+    def verb; end
+  end
 end
 
 class RSpec::Expectations::PositiveExpectationHandler
-  def self.handle_matcher(actual, initial_matcher, message = _, &block); end
-  def self.opposite_should_method; end
-  def self.should_method; end
-  def self.verb; end
+  class << self
+    def handle_matcher(actual, initial_matcher, message = T.unsafe(nil), &block); end
+    def opposite_should_method; end
+    def should_method; end
+    def verb; end
+  end
 end
 
 module RSpec::Expectations::Syntax
@@ -256,24 +281,26 @@ module RSpec::Expectations::Syntax
   private
 
   def default_should_host; end
-  def disable_expect(syntax_host = _); end
-  def disable_should(syntax_host = _); end
-  def enable_expect(syntax_host = _); end
-  def enable_should(syntax_host = _); end
-  def expect_enabled?(syntax_host = _); end
-  def should_enabled?(syntax_host = _); end
+  def disable_expect(syntax_host = T.unsafe(nil)); end
+  def disable_should(syntax_host = T.unsafe(nil)); end
+  def enable_expect(syntax_host = T.unsafe(nil)); end
+  def enable_should(syntax_host = T.unsafe(nil)); end
+  def expect_enabled?(syntax_host = T.unsafe(nil)); end
+  def should_enabled?(syntax_host = T.unsafe(nil)); end
   def warn_about_should!; end
   def warn_about_should_unless_configured(method_name); end
 
-  def self.default_should_host; end
-  def self.disable_expect(syntax_host = _); end
-  def self.disable_should(syntax_host = _); end
-  def self.enable_expect(syntax_host = _); end
-  def self.enable_should(syntax_host = _); end
-  def self.expect_enabled?(syntax_host = _); end
-  def self.should_enabled?(syntax_host = _); end
-  def self.warn_about_should!; end
-  def self.warn_about_should_unless_configured(method_name); end
+  class << self
+    def default_should_host; end
+    def disable_expect(syntax_host = T.unsafe(nil)); end
+    def disable_should(syntax_host = T.unsafe(nil)); end
+    def enable_expect(syntax_host = T.unsafe(nil)); end
+    def enable_should(syntax_host = T.unsafe(nil)); end
+    def expect_enabled?(syntax_host = T.unsafe(nil)); end
+    def should_enabled?(syntax_host = T.unsafe(nil)); end
+    def warn_about_should!; end
+    def warn_about_should_unless_configured(method_name); end
+  end
 end
 
 module RSpec::Expectations::Version
@@ -310,7 +337,7 @@ module RSpec::Matchers
   def a_value(*args, &block); end
   def a_value_between(*args, &block); end
   def a_value_within(*args, &block); end
-  def aggregate_failures(label = _, metadata = _, &block); end
+  def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end
   def all(expected); end
   def an_instance_of(*args, &block); end
   def an_object_eq_to(*args, &block); end
@@ -334,7 +361,7 @@ module RSpec::Matchers
   def be_nil; end
   def be_truthy; end
   def be_within(delta); end
-  def change(receiver = _, message = _, &block); end
+  def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
   def changing(*args, &block); end
   def contain_exactly(*items); end
   def containing_exactly(*args, &block); end
@@ -350,7 +377,7 @@ module RSpec::Matchers
   def equal_to(*args, &block); end
   def exist(*args); end
   def existing(*args, &block); end
-  def expect(value = _, &block); end
+  def expect(value = T.unsafe(nil), &block); end
   def have_attributes(expected); end
   def having_attributes(*args, &block); end
   def include(*expected); end
@@ -359,17 +386,17 @@ module RSpec::Matchers
   def match_array(items); end
   def match_regex(*args, &block); end
   def matching(*args, &block); end
-  def output(expected = _); end
-  def raise_error(error = _, message = _, &block); end
-  def raise_exception(error = _, message = _, &block); end
+  def output(expected = T.unsafe(nil)); end
+  def raise_error(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def raise_exception(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
   def raising(*args, &block); end
   def respond_to(*names); end
   def responding_to(*args, &block); end
-  def satisfy(description = _, &block); end
+  def satisfy(description = T.unsafe(nil), &block); end
   def satisfying(*args, &block); end
   def start_with(*expected); end
   def starting_with(*args, &block); end
-  def throw_symbol(expected_symbol = _, expected_arg = _); end
+  def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
   def throwing(*args, &block); end
   def within(*args, &block); end
   def yield_control; end
@@ -386,17 +413,19 @@ module RSpec::Matchers
   def method_missing(method, *args, &block); end
   def respond_to_missing?(method, *_); end
 
-  def self.alias_matcher(*args, &block); end
-  def self.clear_generated_description; end
-  def self.configuration; end
-  def self.generated_description; end
-  def self.is_a_describable_matcher?(obj); end
-  def self.is_a_matcher?(obj); end
-  def self.last_description; end
-  def self.last_expectation_handler; end
-  def self.last_expectation_handler=(_); end
-  def self.last_matcher; end
-  def self.last_matcher=(_); end
+  class << self
+    def alias_matcher(*args, &block); end
+    def clear_generated_description; end
+    def configuration; end
+    def generated_description; end
+    def is_a_describable_matcher?(obj); end
+    def is_a_matcher?(obj); end
+    def last_description; end
+    def last_expectation_handler; end
+    def last_expectation_handler=(_); end
+    def last_matcher; end
+    def last_matcher=(_); end
+  end
 end
 
 class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator
@@ -454,7 +483,7 @@ class RSpec::Matchers::BuiltIn::BaseMatcher
   include(::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting)
   include(::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages)
 
-  def initialize(expected = _); end
+  def initialize(expected = T.unsafe(nil)); end
 
   def actual; end
   def actual_formatted; end
@@ -475,14 +504,22 @@ class RSpec::Matchers::BuiltIn::BaseMatcher
 
   def assert_ivars(*expected_ivars); end
 
-  def self.matcher_name; end
+  class << self
+    def matcher_name; end
+
+    private
+
+    def underscore(camel_cased_word); end
+  end
 end
 
 module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
   def failure_message; end
   def failure_message_when_negated; end
 
-  def self.has_default_failure_messages?(matcher); end
+  class << self
+    def has_default_failure_messages?(matcher); end
+  end
 end
 
 module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
@@ -491,7 +528,9 @@ module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
 
   def improve_hash_formatting(inspect_string); end
 
-  def self.improve_hash_formatting(inspect_string); end
+  class << self
+    def improve_hash_formatting(inspect_string); end
+  end
 end
 
 RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object)
@@ -628,7 +667,7 @@ class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatch
 end
 
 class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(receiver = _, message = _, &block); end
+  def initialize(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
 
   def by(expected_delta); end
   def by_at_least(minimum); end
@@ -700,7 +739,9 @@ class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
   def inner_matcher_block(outer_args); end
   def order_block_matchers; end
 
-  def self.matcher_expects_call_stack_jump?(matcher); end
+  class << self
+    def matcher_expects_call_stack_jump?(matcher); end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound
@@ -728,14 +769,14 @@ class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::Bas
   def actual_collection_line; end
   def best_solution; end
   def convert_actual_to_an_array; end
-  def describe_collection(collection, surface_descriptions = _); end
+  def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end
   def expected_collection_line; end
   def extra_elements_line; end
   def extra_items; end
   def generate_failure_message; end
   def match(_expected, _actual); end
   def match_when_sorted?; end
-  def message_line(prefix, collection, surface_descriptions = _); end
+  def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end
   def missing_elements_line; end
   def missing_items; end
   def pairings_maximizer; end
@@ -760,7 +801,9 @@ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
 end
 
 class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
-  def self.worse_than?(_other); end
+  class << self
+    def worse_than?(_other); end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct
@@ -778,10 +821,12 @@ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::
   def unmatched_item_count; end
   def worse_than?(other); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher
@@ -969,11 +1014,13 @@ class RSpec::Matchers::BuiltIn::OperatorMatcher
   def eval_match(actual, operator, expected); end
   def has_non_generic_implementation_of?(op); end
 
-  def self.get(klass, operator); end
-  def self.register(klass, operator, matcher); end
-  def self.registry; end
-  def self.unregister(klass, operator); end
-  def self.use_custom_matcher_or_delegate(operator); end
+  class << self
+    def get(klass, operator); end
+    def register(klass, operator, matcher); end
+    def registry; end
+    def unregister(klass, operator); end
+    def use_custom_matcher_or_delegate(operator); end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher
@@ -1006,14 +1053,14 @@ end
 class RSpec::Matchers::BuiltIn::RaiseError
   include(::RSpec::Matchers::Composable)
 
-  def initialize(expected_error_or_message = _, expected_message = _, &block); end
+  def initialize(expected_error_or_message = T.unsafe(nil), expected_message = T.unsafe(nil), &block); end
 
   def description; end
   def does_not_match?(given_proc); end
   def expects_call_stack_jump?; end
   def failure_message; end
   def failure_message_when_negated; end
-  def matches?(given_proc, negative_expectation = _, &block); end
+  def matches?(given_proc, negative_expectation = T.unsafe(nil), &block); end
   def supports_block_expectations?; end
   def with_message(expected_message); end
 
@@ -1070,7 +1117,7 @@ class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatc
 end
 
 class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(description = _, &block); end
+  def initialize(description = T.unsafe(nil), &block); end
 
   def description; end
   def failure_message; end
@@ -1094,7 +1141,7 @@ end
 class RSpec::Matchers::BuiltIn::ThrowSymbol
   include(::RSpec::Matchers::Composable)
 
-  def initialize(expected_symbol = _, expected_arg = _); end
+  def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
 
   def description; end
   def does_not_match?(given_proc); end
@@ -1108,7 +1155,7 @@ class RSpec::Matchers::BuiltIn::ThrowSymbol
 
   def actual_result; end
   def caught; end
-  def expected(symbol_desc = _); end
+  def expected(symbol_desc = T.unsafe(nil)); end
   def throw_description(symbol, arg); end
 end
 
@@ -1202,9 +1249,11 @@ module RSpec::Matchers::Composable
   def values_match?(expected, actual); end
   def with_matchers_cloned(object); end
 
-  def self.should_enumerate?(item); end
-  def self.surface_descriptions_in(item); end
-  def self.unreadable_io?(object); end
+  class << self
+    def should_enumerate?(item); end
+    def surface_descriptions_in(item); end
+    def unreadable_io?(object); end
+  end
 end
 
 class RSpec::Matchers::Composable::DescribableItem < ::Struct
@@ -1213,14 +1262,16 @@ class RSpec::Matchers::Composable::DescribableItem < ::Struct
   def item=(_); end
   def pretty_print(pp); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 module RSpec::Matchers::DSL
-  def alias_matcher(new_name, old_name, options = _, &description_override); end
+  def alias_matcher(new_name, old_name, options = T.unsafe(nil), &description_override); end
   def define(name, &declarations); end
   def define_negated_matcher(negated_name, base_name, &description_override); end
   def matcher(name, &declarations); end
@@ -1249,9 +1300,9 @@ module RSpec::Matchers::DSL::Macros
   def diffable; end
   def failure_message(&definition); end
   def failure_message_when_negated(&definition); end
-  def match(options = _, &match_block); end
-  def match_unless_raises(expected_exception = _, &match_block); end
-  def match_when_negated(options = _, &match_block); end
+  def match(options = T.unsafe(nil), &match_block); end
+  def match_unless_raises(expected_exception = T.unsafe(nil), &match_block); end
+  def match_when_negated(options = T.unsafe(nil), &match_block); end
   def supports_block_expectations; end
 
   private
@@ -1291,14 +1342,16 @@ class RSpec::Matchers::DSL::Matcher
 
   def actual_arg_for(block); end
   def method_missing(method, *args, &block); end
-  def respond_to_missing?(method, include_private = _); end
+  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
 end
 
 RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp)
 
 module RSpec::Matchers::EnglishPhrasing
-  def self.list(obj); end
-  def self.split_words(sym); end
+  class << self
+    def list(obj); end
+    def split_words(sym); end
+  end
 end
 
 class RSpec::Matchers::ExpectedsForMultipleDiffs
@@ -1310,8 +1363,15 @@ class RSpec::Matchers::ExpectedsForMultipleDiffs
 
   def diffs(differ, actual); end
 
-  def self.for_many_matchers(matchers); end
-  def self.from(expected); end
+  class << self
+    def for_many_matchers(matchers); end
+    def from(expected); end
+
+    private
+
+    def diff_label_for(matcher); end
+    def truncated(description); end
+  end
 end
 
 RSpec::Matchers::ExpectedsForMultipleDiffs::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String)
@@ -1331,7 +1391,7 @@ class RSpec::Matchers::MatcherDelegator
   private
 
   def initialize_copy(other); end
-  def respond_to_missing?(name, include_all = _); end
+  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
 end
 
 module RSpec::Matchers::BuiltIn::BeHelpers
@@ -1346,13 +1406,17 @@ module RSpec::Matchers::BuiltIn::BeHelpers
 end
 
 module RSpec::Matchers::BuiltIn::CaptureStderr
-  def self.capture(block); end
-  def self.name; end
+  class << self
+    def capture(block); end
+    def name; end
+  end
 end
 
 module RSpec::Matchers::BuiltIn::CaptureStdout
-  def self.capture(block); end
-  def self.name; end
+  class << self
+    def capture(block); end
+    def name; end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct
@@ -1360,7 +1424,7 @@ class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct
 end
 
 class RSpec::Matchers::BuiltIn::ChangeDetails
-  def initialize(matcher_name, receiver = _, message = _, &block); end
+  def initialize(matcher_name, receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
 
   def actual_after; end
   def actual_delta; end
@@ -1413,8 +1477,10 @@ class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::Spec
 end
 
 module RSpec::Matchers::BuiltIn::NullCapture
-  def self.capture(_block); end
-  def self.name; end
+  class << self
+    def capture(_block); end
+    def name; end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::ReliableMatchData
@@ -1478,5 +1544,7 @@ class RSpec::Matchers::BuiltIn::YieldProbe
   def yielded_args=(_); end
   def yielded_once?(matcher_name); end
 
-  def self.probe(block, &callback); end
+  class << self
+    def probe(block, &callback); end
+  end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi
index 27b1fb4bc6..a0e7530772 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-its` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.9.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.9.1.rbi
index c043a8530b..91fe84d503 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.9.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.9.1.rbi
@@ -1,18 +1,21 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-mocks` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module RSpec::Mocks
-  def self.allow_message(subject, message, opts = _, &block); end
-  def self.configuration; end
-  def self.error_generator; end
-  def self.expect_message(subject, message, opts = _, &block); end
-  def self.setup; end
-  def self.space; end
-  def self.teardown; end
-  def self.verify; end
-  def self.with_temporary_scope; end
+  class << self
+    def allow_message(subject, message, opts = T.unsafe(nil), &block); end
+    def configuration; end
+    def error_generator; end
+    def expect_message(subject, message, opts = T.unsafe(nil), &block); end
+    def setup; end
+    def space; end
+    def teardown; end
+    def verify; end
+    def with_temporary_scope; end
+  end
 end
 
 class RSpec::Mocks::AllowanceTarget < ::RSpec::Mocks::TargetBase
@@ -53,7 +56,9 @@ class RSpec::Mocks::AndYieldImplementation
 end
 
 module RSpec::Mocks::AnyInstance
-  def self.error_generator; end
+  class << self
+    def error_generator; end
+  end
 end
 
 class RSpec::Mocks::AnyInstance::Chain
@@ -94,7 +99,9 @@ module RSpec::Mocks::AnyInstance::Chain::Customizations
   def twice(*args, &block); end
   def with(*args, &block); end
 
-  def self.record(method_name); end
+  class << self
+    def record(method_name); end
+  end
 end
 
 class RSpec::Mocks::AnyInstance::ErrorGenerator < ::RSpec::Mocks::ErrorGenerator
@@ -133,7 +140,7 @@ class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
 
   private
 
-  def respond_to_missing?(method_name, include_private = _); end
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
 end
 
 class RSpec::Mocks::AnyInstance::MessageChains
@@ -289,7 +296,9 @@ module RSpec::Mocks::ArgumentMatchers
   def kind_of(klass); end
   def no_args; end
 
-  def self.anythingize_lonely_keys(*args); end
+  class << self
+    def anythingize_lonely_keys(*args); end
+  end
 end
 
 class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
@@ -372,7 +381,9 @@ end
 RSpec::Mocks::ArgumentMatchers::NoArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::NoArgsMatcher)
 
 class RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def self.inherited(subklass); end
+  class << self
+    def inherited(subklass); end
+  end
 end
 
 class RSpec::Mocks::CallbackInvocationStrategy
@@ -385,7 +396,9 @@ end
 class RSpec::Mocks::ClassNewMethodReference < ::RSpec::Mocks::ObjectMethodReference
   def with_signature; end
 
-  def self.applies_to?(method_name); end
+  class << self
+    def applies_to?(method_name); end
+  end
 end
 
 class RSpec::Mocks::ClassVerifyingDouble < ::Module
@@ -440,17 +453,21 @@ class RSpec::Mocks::Constant
   def valid_name=(_); end
   def valid_name?; end
 
-  def self.original(name); end
-  def self.unmutated(name); end
+  class << self
+    def original(name); end
+    def unmutated(name); end
+  end
 end
 
 class RSpec::Mocks::ConstantMutator
   extend(::RSpec::Support::RecursiveConstMethods)
 
-  def self.hide(constant_name); end
-  def self.mutate(mutator); end
-  def self.raise_on_invalid_const; end
-  def self.stub(constant_name, value, options = _); end
+  class << self
+    def hide(constant_name); end
+    def mutate(mutator); end
+    def raise_on_invalid_const; end
+    def stub(constant_name, value, options = T.unsafe(nil)); end
+  end
 end
 
 class RSpec::Mocks::ConstantMutator::BaseMutator
@@ -508,19 +525,19 @@ class RSpec::Mocks::Double
 end
 
 class RSpec::Mocks::ErrorGenerator
-  def initialize(target = _); end
+  def initialize(target = T.unsafe(nil)); end
 
   def default_error_message(expectation, expected_args, actual_args); end
   def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end
   def expectation_on_nil_message(method_name); end
-  def intro(unwrapped = _); end
-  def method_call_args_description(args, generic_prefix = _, matcher_prefix = _); end
+  def intro(unwrapped = T.unsafe(nil)); end
+  def method_call_args_description(args, generic_prefix = T.unsafe(nil), matcher_prefix = T.unsafe(nil)); end
   def opts; end
   def opts=(_); end
   def raise_already_invoked_error(message, calling_customization); end
   def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end
   def raise_double_negation_error(wrapped_expression); end
-  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = _, source_id = _); end
+  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
   def raise_expectation_on_mocked_method(method); end
   def raise_expectation_on_nil_error(method_name); end
   def raise_expectation_on_unstubbed_method(method); end
@@ -533,8 +550,8 @@ class RSpec::Mocks::ErrorGenerator
   def raise_non_public_error(method_name, visibility); end
   def raise_only_valid_on_a_partial_double(method); end
   def raise_out_of_order_error(message); end
-  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = _); end
-  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = _); end
+  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = T.unsafe(nil)); end
+  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = T.unsafe(nil)); end
   def raise_unexpected_message_error(message, args); end
   def raise_unimplemented_error(doubled_module, method_name, object); end
   def raise_verifying_double_not_defined_error(ref); end
@@ -542,9 +559,9 @@ class RSpec::Mocks::ErrorGenerator
 
   private
 
-  def __raise(message, backtrace_line = _, source_id = _); end
+  def __raise(message, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
   def arg_list(args); end
-  def count_message(count, expectation_count_type = _); end
+  def count_message(count, expectation_count_type = T.unsafe(nil)); end
   def diff_message(expected_args, actual_args); end
   def differ; end
   def error_message(expectation, args_for_multiple_calls); end
@@ -584,13 +601,15 @@ module RSpec::Mocks::ExampleMethods
   def receive_message_chain(*messages, &block); end
   def receive_messages(message_return_value_hash); end
   def spy(*args); end
-  def stub_const(constant_name, value, options = _); end
+  def stub_const(constant_name, value, options = T.unsafe(nil)); end
   def without_partial_double_verification; end
 
-  def self.declare_double(type, *args); end
-  def self.declare_verifying_double(type, ref, *args); end
-  def self.extended(object); end
-  def self.included(klass); end
+  class << self
+    def declare_double(type, *args); end
+    def declare_verifying_double(type, ref, *args); end
+    def extended(object); end
+    def included(klass); end
+  end
 end
 
 module RSpec::Mocks::ExampleMethods::ExpectHost
@@ -603,7 +622,9 @@ class RSpec::Mocks::ExpectChain < ::RSpec::Mocks::MessageChain
 
   def expectation(object, message, &return_block); end
 
-  def self.expect_chain_on(object, *chain, &blk); end
+  class << self
+    def expect_chain_on(object, *chain, &blk); end
+  end
 end
 
 class RSpec::Mocks::ExpectationTarget < ::RSpec::Mocks::TargetBase
@@ -662,7 +683,7 @@ class RSpec::Mocks::InstanceMethodStasher
   private
 
   def method_defined_directly_on_klass?; end
-  def method_defined_on_klass?(klass = _); end
+  def method_defined_on_klass?(klass = T.unsafe(nil)); end
   def method_owned_by_klass?; end
 end
 
@@ -674,8 +695,10 @@ class RSpec::Mocks::InstanceVerifyingDouble
 end
 
 class RSpec::Mocks::MarshalExtension
-  def self.patch!; end
-  def self.unpatch!; end
+  class << self
+    def patch!; end
+    def unpatch!; end
+  end
 end
 
 module RSpec::Mocks::Matchers
@@ -714,7 +737,7 @@ class RSpec::Mocks::Matchers::HaveReceived
   def apply_constraints_to(expectation); end
   def capture_failure_message; end
   def count_constraint; end
-  def disallow(type, reason = _); end
+  def disallow(type, reason = T.unsafe(nil)); end
   def ensure_count_unconstrained; end
   def expect; end
   def expected_messages_received_in_order?; end
@@ -855,7 +878,7 @@ class RSpec::Mocks::MessageExpectation
 end
 
 module RSpec::Mocks::MessageExpectation::ImplementationDetails
-  def initialize(error_generator, expectation_ordering, expected_from, method_double, type = _, opts = _, &implementation_block); end
+  def initialize(error_generator, expectation_ordering, expected_from, method_double, type = T.unsafe(nil), opts = T.unsafe(nil), &implementation_block); end
 
   def actual_received_count_matters?; end
   def additional_expected_calls; end
@@ -922,7 +945,7 @@ class RSpec::Mocks::MethodDouble
   def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end
   def add_simple_expectation(method_name, response, error_generator, backtrace_line); end
   def add_simple_stub(method_name, response); end
-  def add_stub(error_generator, expectation_ordering, expected_from, opts = _, &implementation); end
+  def add_stub(error_generator, expectation_ordering, expected_from, opts = T.unsafe(nil), &implementation); end
   def build_expectation(error_generator, expectation_ordering); end
   def clear; end
   def configure_method; end
@@ -943,7 +966,7 @@ class RSpec::Mocks::MethodDouble
   def restore_original_method; end
   def restore_original_visibility; end
   def save_original_implementation_callable!; end
-  def setup_simple_method_double(method_name, response, collection, error_generator = _, backtrace_line = _); end
+  def setup_simple_method_double(method_name, response, collection, error_generator = T.unsafe(nil), backtrace_line = T.unsafe(nil)); end
   def show_frozen_warning; end
   def stubs; end
   def verify; end
@@ -973,10 +996,12 @@ class RSpec::Mocks::MethodReference
 
   def original_method; end
 
-  def self.for(object_reference, method_name); end
-  def self.instance_method_visibility_for(klass, method_name); end
-  def self.method_defined_at_any_visibility?(klass, method_name); end
-  def self.method_visibility_for(object, method_name); end
+  class << self
+    def for(object_reference, method_name); end
+    def instance_method_visibility_for(klass, method_name); end
+    def method_defined_at_any_visibility?(klass, method_name); end
+    def method_visibility_for(object, method_name); end
+  end
 end
 
 class RSpec::Mocks::MockExpectationAlreadyInvokedError < ::Exception
@@ -1028,11 +1053,20 @@ class RSpec::Mocks::ObjectMethodReference < ::RSpec::Mocks::MethodReference
   def method_implemented?(object); end
   def visibility_from(object); end
 
-  def self.for(object_reference, method_name); end
+  class << self
+    def for(object_reference, method_name); end
+  end
 end
 
 class RSpec::Mocks::ObjectReference
-  def self.for(object_module_or_name, allow_direct_object_refs = _); end
+  class << self
+    def for(object_module_or_name, allow_direct_object_refs = T.unsafe(nil)); end
+
+    private
+
+    def anonymous_module?(mod); end
+    def name_of(mod); end
+  end
 end
 
 RSpec::Mocks::ObjectReference::MODULE_NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
@@ -1047,7 +1081,7 @@ module RSpec::Mocks::ObjectVerifyingDoubleMethods
   include(::RSpec::Mocks::TestDouble)
   include(::RSpec::Mocks::VerifyingDouble)
 
-  def as_stubbed_const(options = _); end
+  def as_stubbed_const(options = T.unsafe(nil)); end
 
   private
 
@@ -1108,12 +1142,12 @@ class RSpec::Mocks::PartialDoubleProxy < ::RSpec::Mocks::Proxy
 end
 
 class RSpec::Mocks::Proxy
-  def initialize(object, order_group, options = _); end
+  def initialize(object, order_group, options = T.unsafe(nil)); end
 
-  def add_message_expectation(method_name, opts = _, &block); end
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
   def add_simple_expectation(method_name, response, location); end
   def add_simple_stub(method_name, response); end
-  def add_stub(method_name, opts = _, &implementation); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
   def as_null_object; end
   def build_expectation(method_name); end
   def check_for_unexpected_arguments(expectation); end
@@ -1146,7 +1180,9 @@ class RSpec::Mocks::Proxy
   def find_matching_method_stub(method_name, *args); end
   def method_double_for(message); end
 
-  def self.prepended_modules_of(klass); end
+  class << self
+    def prepended_modules_of(klass); end
+  end
 end
 
 RSpec::Mocks::Proxy::DEFAULT_MESSAGE_EXPECTATION_OPTS = T.let(T.unsafe(nil), Hash)
@@ -1160,17 +1196,19 @@ class RSpec::Mocks::Proxy::SpecificMessage < ::Struct
   def object; end
   def object=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Mocks::ProxyForNil < ::RSpec::Mocks::PartialDoubleProxy
   def initialize(order_group); end
 
-  def add_message_expectation(method_name, opts = _, &block); end
-  def add_stub(method_name, opts = _, &implementation); end
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
   def disallow_expectations; end
   def disallow_expectations=(_); end
   def warn_about_expectations; end
@@ -1202,7 +1240,7 @@ class RSpec::Mocks::RootSpace
 end
 
 class RSpec::Mocks::SimpleMessageExpectation
-  def initialize(message, response, error_generator, backtrace_line = _); end
+  def initialize(message, response, error_generator, backtrace_line = T.unsafe(nil)); end
 
   def called_max_times?; end
   def invoke(*_); end
@@ -1216,7 +1254,7 @@ class RSpec::Mocks::Space
 
   def any_instance_mutex; end
   def any_instance_proxy_for(klass); end
-  def any_instance_recorder_for(klass, only_return_existing = _); end
+  def any_instance_recorder_for(klass, only_return_existing = T.unsafe(nil)); end
   def any_instance_recorders; end
   def any_instance_recorders_from_ancestry_of(object); end
   def constant_mutator_for(name); end
@@ -1248,19 +1286,23 @@ class RSpec::Mocks::StubChain < ::RSpec::Mocks::MessageChain
 
   def expectation(object, message, &return_block); end
 
-  def self.stub_chain_on(object, *chain, &blk); end
+  class << self
+    def stub_chain_on(object, *chain, &blk); end
+  end
 end
 
 module RSpec::Mocks::Syntax
-  def self.default_should_syntax_host; end
-  def self.disable_expect(syntax_host = _); end
-  def self.disable_should(syntax_host = _); end
-  def self.enable_expect(syntax_host = _); end
-  def self.enable_should(syntax_host = _); end
-  def self.expect_enabled?(syntax_host = _); end
-  def self.should_enabled?(syntax_host = _); end
-  def self.warn_about_should!; end
-  def self.warn_unless_should_configured(method_name, replacement = _); end
+  class << self
+    def default_should_syntax_host; end
+    def disable_expect(syntax_host = T.unsafe(nil)); end
+    def disable_should(syntax_host = T.unsafe(nil)); end
+    def enable_expect(syntax_host = T.unsafe(nil)); end
+    def enable_should(syntax_host = T.unsafe(nil)); end
+    def expect_enabled?(syntax_host = T.unsafe(nil)); end
+    def should_enabled?(syntax_host = T.unsafe(nil)); end
+    def warn_about_should!; end
+    def warn_unless_should_configured(method_name, replacement = T.unsafe(nil)); end
+  end
 end
 
 class RSpec::Mocks::TargetBase
@@ -1271,7 +1313,7 @@ class RSpec::Mocks::TargetBase
 end
 
 module RSpec::Mocks::TargetDelegationClassMethods
-  def delegate_not_to(matcher_method, options = _); end
+  def delegate_not_to(matcher_method, options = T.unsafe(nil)); end
   def delegate_to(matcher_method); end
   def disallow_negation(method_name); end
 end
@@ -1288,7 +1330,7 @@ module RSpec::Mocks::TargetDelegationInstanceMethods
 end
 
 module RSpec::Mocks::TestDouble
-  def initialize(name = _, stubs = _); end
+  def initialize(name = T.unsafe(nil), stubs = T.unsafe(nil)); end
 
   def ==(other); end
   def __build_mock_proxy_unless_expired(order_group); end
@@ -1297,7 +1339,7 @@ module RSpec::Mocks::TestDouble
   def freeze; end
   def inspect; end
   def null_object?; end
-  def respond_to?(message, incl_private = _); end
+  def respond_to?(message, incl_private = T.unsafe(nil)); end
   def to_s; end
 
   private
@@ -1311,7 +1353,15 @@ module RSpec::Mocks::TestDouble
 end
 
 module RSpec::Mocks::TestDoubleFormatter
-  def self.format(dbl, unwrap = _); end
+  class << self
+    def format(dbl, unwrap = T.unsafe(nil)); end
+
+    private
+
+    def name_desc(dbl); end
+    def type_desc(dbl); end
+    def verified_module_desc(dbl); end
+  end
 end
 
 class RSpec::Mocks::TestDoubleProxy < ::RSpec::Mocks::Proxy
@@ -1326,13 +1376,15 @@ module RSpec::Mocks::VerifyingDouble
 
   def __send__(name, *args, &block); end
   def method_missing(message, *args, &block); end
-  def respond_to?(message, include_private = _); end
+  def respond_to?(message, include_private = T.unsafe(nil)); end
   def send(name, *args, &block); end
 end
 
 module RSpec::Mocks::VerifyingDouble::SilentIO
-  def self.method_missing(*_); end
-  def self.respond_to?(*_); end
+  class << self
+    def method_missing(*_); end
+    def respond_to?(*_); end
+  end
 end
 
 class RSpec::Mocks::VerifyingDoubleNotDefinedError < ::StandardError
@@ -1348,7 +1400,9 @@ class RSpec::Mocks::VerifyingExistingMethodDouble < ::RSpec::Mocks::VerifyingMet
   def unimplemented?; end
   def with_signature; end
 
-  def self.for(object, method_name, proxy); end
+  class << self
+    def for(object, method_name, proxy); end
+  end
 end
 
 class RSpec::Mocks::VerifyingMessageExpectation < ::RSpec::Mocks::MessageExpectation
@@ -1380,7 +1434,7 @@ end
 class RSpec::Mocks::VerifyingPartialDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
   include(::RSpec::Mocks::VerifyingProxyMethods)
 
-  def initialize(object, expectation_ordering, optional_callback_invocation_strategy = _); end
+  def initialize(object, expectation_ordering, optional_callback_invocation_strategy = T.unsafe(nil)); end
 
   def ensure_implemented(_method_name); end
   def method_reference; end
@@ -1397,9 +1451,9 @@ class RSpec::Mocks::VerifyingProxy < ::RSpec::Mocks::TestDoubleProxy
 end
 
 module RSpec::Mocks::VerifyingProxyMethods
-  def add_message_expectation(method_name, opts = _, &block); end
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
   def add_simple_stub(method_name, *args); end
-  def add_stub(method_name, opts = _, &implementation); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
   def ensure_implemented(method_name); end
   def ensure_publicly_implemented(method_name, _object); end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi
index 27b1fb4bc6..328046941f 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-retry` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi
index 74efb9a0b7..95850f657b 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-support` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -7,30 +8,34 @@ module RSpec
   extend(::RSpec::Support::Warnings)
   extend(::RSpec::Core::Warnings)
 
-  def self.clear_examples; end
-  def self.configuration; end
-  def self.configuration=(_); end
-  def self.configure; end
-  def self.const_missing(name); end
-  def self.context(*args, &example_group_block); end
-  def self.current_example; end
-  def self.current_example=(example); end
-  def self.describe(*args, &example_group_block); end
-  def self.example_group(*args, &example_group_block); end
-  def self.fcontext(*args, &example_group_block); end
-  def self.fdescribe(*args, &example_group_block); end
-  def self.reset; end
-  def self.shared_context(name, *args, &block); end
-  def self.shared_examples(name, *args, &block); end
-  def self.shared_examples_for(name, *args, &block); end
-  def self.world; end
-  def self.world=(_); end
-  def self.xcontext(*args, &example_group_block); end
-  def self.xdescribe(*args, &example_group_block); end
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
 end
 
 class RSpec::CallerFilter
-  def self.first_non_rspec_line(skip_frames = _, increment = _); end
+  class << self
+    def first_non_rspec_line(skip_frames = T.unsafe(nil), increment = T.unsafe(nil)); end
+  end
 end
 
 RSpec::CallerFilter::ADDITIONAL_TOP_LEVEL_FILES = T.let(T.unsafe(nil), Array)
@@ -46,30 +51,34 @@ RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
 RSpec::SharedContext = RSpec::Core::SharedContext
 
 module RSpec::Support
-  def self.class_of(object); end
-  def self.define_optimized_require_for_rspec(lib, &require_relative); end
-  def self.deregister_matcher_definition(&block); end
-  def self.failure_notifier; end
-  def self.failure_notifier=(callable); end
-  def self.is_a_matcher?(object); end
-  def self.matcher_definitions; end
-  def self.method_handle_for(object, method_name); end
-  def self.notify_failure(failure, options = _); end
-  def self.register_matcher_definition(&block); end
-  def self.require_rspec_core(f); end
-  def self.require_rspec_expectations(f); end
-  def self.require_rspec_matchers(f); end
-  def self.require_rspec_mocks(f); end
-  def self.require_rspec_support(f); end
-  def self.rspec_description_for_object(object); end
-  def self.thread_local_data; end
-  def self.warning_notifier; end
-  def self.warning_notifier=(_); end
-  def self.with_failure_notifier(callable); end
+  class << self
+    def class_of(object); end
+    def define_optimized_require_for_rspec(lib, &require_relative); end
+    def deregister_matcher_definition(&block); end
+    def failure_notifier; end
+    def failure_notifier=(callable); end
+    def is_a_matcher?(object); end
+    def matcher_definitions; end
+    def method_handle_for(object, method_name); end
+    def notify_failure(failure, options = T.unsafe(nil)); end
+    def register_matcher_definition(&block); end
+    def require_rspec_core(f); end
+    def require_rspec_expectations(f); end
+    def require_rspec_matchers(f); end
+    def require_rspec_mocks(f); end
+    def require_rspec_support(f); end
+    def rspec_description_for_object(object); end
+    def thread_local_data; end
+    def warning_notifier; end
+    def warning_notifier=(_); end
+    def with_failure_notifier(callable); end
+  end
 end
 
 module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
-  def self.===(exception); end
+  class << self
+    def ===(exception); end
+  end
 end
 
 RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue::AVOID_RESCUING = T.let(T.unsafe(nil), Array)
@@ -93,7 +102,7 @@ RSpec::Support::DEFAULT_FAILURE_NOTIFIER = T.let(T.unsafe(nil), Proc)
 RSpec::Support::DEFAULT_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)
 
 class RSpec::Support::Differ
-  def initialize(opts = _); end
+  def initialize(opts = T.unsafe(nil)); end
 
   def color?; end
   def diff(actual, expected); end
@@ -127,11 +136,19 @@ class RSpec::Support::Differ
 end
 
 class RSpec::Support::DirectoryMaker
-  def self.mkdir_p(path); end
+  class << self
+    def mkdir_p(path); end
+
+    private
+
+    def directory_exists?(dirname); end
+    def generate_path(stack, part); end
+    def generate_stack(path); end
+  end
 end
 
 class RSpec::Support::EncodedString
-  def initialize(string, encoding = _); end
+  def initialize(string, encoding = T.unsafe(nil)); end
 
   def <<(string); end
   def ==(*args, &block); end
@@ -150,7 +167,9 @@ class RSpec::Support::EncodedString
   def matching_encoding(string); end
   def remove_invalid_bytes(string); end
 
-  def self.pick_encoding(source_a, source_b); end
+  class << self
+    def pick_encoding(source_a, source_b); end
+  end
 end
 
 RSpec::Support::EncodedString::REPLACE = T.let(T.unsafe(nil), String)
@@ -160,7 +179,14 @@ RSpec::Support::EncodedString::US_ASCII = T.let(T.unsafe(nil), String)
 RSpec::Support::EncodedString::UTF_8 = T.let(T.unsafe(nil), String)
 
 module RSpec::Support::FuzzyMatcher
-  def self.values_match?(expected, actual); end
+  class << self
+    def values_match?(expected, actual); end
+
+    private
+
+    def arrays_match?(expected_list, actual_list); end
+    def hashes_match?(expected_hash, actual_hash); end
+  end
 end
 
 RSpec::Support::KERNEL_METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
@@ -186,7 +212,7 @@ class RSpec::Support::MethodSignature
   def initialize(method); end
 
   def arbitrary_kw_args?; end
-  def classify_arity(arity = _); end
+  def classify_arity(arity = T.unsafe(nil)); end
   def classify_parameters; end
   def could_contain_kw_args?(args); end
   def description; end
@@ -199,7 +225,7 @@ class RSpec::Support::MethodSignature
   def optional_kw_args; end
   def required_kw_args; end
   def unlimited_args?; end
-  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = _); end
+  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = T.unsafe(nil)); end
 end
 
 RSpec::Support::MethodSignature::INFINITY = T.let(T.unsafe(nil), Float)
@@ -221,7 +247,7 @@ class RSpec::Support::MethodSignatureExpectation
 end
 
 class RSpec::Support::MethodSignatureVerifier
-  def initialize(signature, args = _); end
+  def initialize(signature, args = T.unsafe(nil)); end
 
   def error_message; end
   def kw_args; end
@@ -242,7 +268,9 @@ class RSpec::Support::MethodSignatureVerifier
 end
 
 class RSpec::Support::Mutex < ::Thread::Mutex
-  def self.new; end
+  class << self
+    def new; end
+  end
 end
 
 RSpec::Support::Mutex::NEW_MUTEX_METHOD = T.let(T.unsafe(nil), Method)
@@ -254,12 +282,14 @@ module RSpec::Support::OS
   def windows?; end
   def windows_file_path?; end
 
-  def self.windows?; end
-  def self.windows_file_path?; end
+  class << self
+    def windows?; end
+    def windows_file_path?; end
+  end
 end
 
 class RSpec::Support::ObjectFormatter
-  def initialize(max_formatted_output_length = _); end
+  def initialize(max_formatted_output_length = T.unsafe(nil)); end
 
   def format(object); end
   def max_formatted_output_length; end
@@ -276,9 +306,11 @@ class RSpec::Support::ObjectFormatter
 
   def truncate_string(str, start_index, end_index); end
 
-  def self.default_instance; end
-  def self.format(object); end
-  def self.prepare_for_inspection(object); end
+  class << self
+    def default_instance; end
+    def format(object); end
+    def prepare_for_inspection(object); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct
@@ -289,23 +321,29 @@ class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct
   def object=(_); end
   def pretty_print(pp); end
 
-  def self.[](*_); end
-  def self.can_inspect?(_object); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def can_inspect?(_object); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::BigDecimalInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::DateTimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil), String)
@@ -313,13 +351,17 @@ RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil)
 class RSpec::Support::ObjectFormatter::DelegatorInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 RSpec::Support::ObjectFormatter::ELLIPSIS = T.let(T.unsafe(nil), String)
@@ -332,22 +374,28 @@ class RSpec::Support::ObjectFormatter::InspectableItem < ::Struct
   def text; end
   def text=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::InspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::TimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 RSpec::Support::ObjectFormatter::TimeInspector::FORMAT = T.let(T.unsafe(nil), String)
@@ -357,7 +405,9 @@ class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < ::RSpec::S
   def klass; end
   def native_object_id; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 RSpec::Support::ObjectFormatter::UninspectableObjectInspector::OBJECT_ID_FORMAT = T.let(T.unsafe(nil), String)
@@ -394,13 +444,15 @@ module RSpec::Support::Ruby
   def rbx?; end
   def truffleruby?; end
 
-  def self.jruby?; end
-  def self.jruby_9000?; end
-  def self.jruby_version; end
-  def self.mri?; end
-  def self.non_mri?; end
-  def self.rbx?; end
-  def self.truffleruby?; end
+  class << self
+    def jruby?; end
+    def jruby_9000?; end
+    def jruby_version; end
+    def mri?; end
+    def non_mri?; end
+    def rbx?; end
+    def truffleruby?; end
+  end
 end
 
 module RSpec::Support::RubyFeatures
@@ -419,17 +471,19 @@ module RSpec::Support::RubyFeatures
   def supports_rebinding_module_methods?; end
   def supports_taint?; end
 
-  def self.caller_locations_supported?; end
-  def self.fork_supported?; end
-  def self.kw_args_supported?; end
-  def self.module_prepends_supported?; end
-  def self.module_refinement_supported?; end
-  def self.optional_and_splat_args_supported?; end
-  def self.required_kw_args_supported?; end
-  def self.ripper_supported?; end
-  def self.supports_exception_cause?; end
-  def self.supports_rebinding_module_methods?; end
-  def self.supports_taint?; end
+  class << self
+    def caller_locations_supported?; end
+    def fork_supported?; end
+    def kw_args_supported?; end
+    def module_prepends_supported?; end
+    def module_refinement_supported?; end
+    def optional_and_splat_args_supported?; end
+    def required_kw_args_supported?; end
+    def ripper_supported?; end
+    def supports_exception_cause?; end
+    def supports_rebinding_module_methods?; end
+    def supports_taint?; end
+  end
 end
 
 RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier
@@ -440,10 +494,10 @@ end
 RSpec::Support::Version::STRING = T.let(T.unsafe(nil), String)
 
 module RSpec::Support::Warnings
-  def deprecate(deprecated, options = _); end
-  def warn_deprecation(message, options = _); end
-  def warn_with(message, options = _); end
-  def warning(text, options = _); end
+  def deprecate(deprecated, options = T.unsafe(nil)); end
+  def warn_deprecation(message, options = T.unsafe(nil)); end
+  def warn_with(message, options = T.unsafe(nil)); end
+  def warning(text, options = T.unsafe(nil)); end
 end
 
 module RSpec::Support::WithKeywordsWhenNeeded
@@ -452,7 +506,9 @@ module RSpec::Support::WithKeywordsWhenNeeded
 
   def class_exec(klass, *args, &block); end
 
-  def self.class_exec(klass, *args, &block); end
+  class << self
+    def class_exec(klass, *args, &block); end
+  end
 end
 
 class RSpec::Support::HunkGenerator
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi
index 27b1fb4bc6..f94543a332 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-wait` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi
index 45d159360b..4506114441 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -7,26 +8,28 @@ module RSpec
   extend(::RSpec::Support::Warnings)
   extend(::RSpec::Core::Warnings)
 
-  def self.clear_examples; end
-  def self.configuration; end
-  def self.configuration=(_); end
-  def self.configure; end
-  def self.const_missing(name); end
-  def self.context(*args, &example_group_block); end
-  def self.current_example; end
-  def self.current_example=(example); end
-  def self.describe(*args, &example_group_block); end
-  def self.example_group(*args, &example_group_block); end
-  def self.fcontext(*args, &example_group_block); end
-  def self.fdescribe(*args, &example_group_block); end
-  def self.reset; end
-  def self.shared_context(name, *args, &block); end
-  def self.shared_examples(name, *args, &block); end
-  def self.shared_examples_for(name, *args, &block); end
-  def self.world; end
-  def self.world=(_); end
-  def self.xcontext(*args, &example_group_block); end
-  def self.xdescribe(*args, &example_group_block); end
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
 end
 
 RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.3.0.rbi
similarity index 90%
rename from Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.2.0.rbi
rename to Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.3.0.rbi
index 42c899a54c..abc34c1093 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.2.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.3.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop-ast` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -31,7 +32,7 @@ end
 class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node
   def bracketed?; end
   def each_value(&block); end
-  def percent_literal?(type = _); end
+  def percent_literal?(type = T.unsafe(nil)); end
   def square_brackets?; end
   def values; end
 end
@@ -70,11 +71,8 @@ end
 RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array)
 
 class RuboCop::AST::BreakNode < ::RuboCop::AST::Node
-  include(::RuboCop::AST::MethodIdentifierPredicates)
-  include(::RuboCop::AST::MethodDispatchNode)
   include(::RuboCop::AST::ParameterizedNode)
-
-  def arguments; end
+  include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
 end
 
 class RuboCop::AST::Builder < ::Parser::Builders::Default
@@ -91,7 +89,7 @@ RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash)
 class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ConditionalNode)
 
-  def each_in_pattern; end
+  def each_in_pattern(&block); end
   def else?; end
   def else_branch; end
   def in_pattern_branches; end
@@ -101,7 +99,8 @@ end
 class RuboCop::AST::CaseNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ConditionalNode)
 
-  def each_when; end
+  def branches; end
+  def each_when(&block); end
   def else?; end
   def else_branch; end
   def keyword; end
@@ -274,6 +273,7 @@ class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
+  def arguments; end
   def node_parts; end
 end
 
@@ -281,7 +281,15 @@ class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node
   def body; end
 end
 
+module RuboCop::AST::Ext
+end
+
+module RuboCop::AST::Ext::Range
+  def line_span(exclude_end: T.unsafe(nil)); end
+end
+
 class RuboCop::AST::FloatNode < ::RuboCop::AST::Node
+  include(::RuboCop::AST::BasicLiteralNode)
   include(::RuboCop::AST::NumericNode)
 end
 
@@ -303,7 +311,7 @@ end
 module RuboCop::AST::HashElementNode
   def delimiter_delta(other); end
   def key; end
-  def key_delta(other, alignment = _); end
+  def key_delta(other, alignment = T.unsafe(nil)); end
   def same_line?(other); end
   def value; end
   def value_delta(other); end
@@ -311,9 +319,9 @@ end
 
 class RuboCop::AST::HashNode < ::RuboCop::AST::Node
   def braces?; end
-  def each_key; end
+  def each_key(&block); end
   def each_pair; end
-  def each_value; end
+  def each_value(&block); end
   def empty?; end
   def keys; end
   def mixed_delimiters?; end
@@ -327,7 +335,7 @@ class RuboCop::AST::IfNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ModifierNode)
 
   def branches; end
-  def each_branch; end
+  def each_branch(&block); end
   def else?; end
   def else_branch; end
   def elsif?; end
@@ -345,27 +353,36 @@ end
 
 class RuboCop::AST::IndexNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::RestArguments)
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
-  def arguments; end
   def assignment_method?; end
   def attribute_accessor?; end
   def method_name; end
+
+  private
+
+  def first_argument_index; end
 end
 
 class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::RestArguments)
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
-  def arguments; end
   def assignment_method?; end
   def attribute_accessor?; end
   def method_name; end
+
+  private
+
+  def first_argument_index; end
 end
 
 class RuboCop::AST::IntNode < ::RuboCop::AST::Node
+  include(::RuboCop::AST::BasicLiteralNode)
   include(::RuboCop::AST::NumericNode)
 end
 
@@ -382,15 +399,20 @@ RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String)
 
 class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::RestArguments)
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
-  def arguments; end
   def assignment_method?; end
   def attribute_accessor?; end
   def lambda?; end
   def lambda_literal?; end
   def method_name; end
+  def receiver; end
+
+  private
+
+  def first_argument_index; end
 end
 
 module RuboCop::AST::MethodDispatchNode
@@ -398,12 +420,11 @@ module RuboCop::AST::MethodDispatchNode
   extend(::RuboCop::AST::NodePattern::Macros)
 
   def access_modifier?; end
-  def adjacent_def_modifier?(node = _); end
-  def arguments; end
+  def adjacent_def_modifier?(node = T.unsafe(nil)); end
   def arithmetic_operation?; end
   def assignment?; end
   def bare_access_modifier?; end
-  def bare_access_modifier_declaration?(node = _); end
+  def bare_access_modifier_declaration?(node = T.unsafe(nil)); end
   def binary_operation?; end
   def block_literal?; end
   def block_node; end
@@ -416,10 +437,10 @@ module RuboCop::AST::MethodDispatchNode
   def lambda?; end
   def lambda_literal?; end
   def macro?; end
-  def macro_scope?(node = _); end
+  def macro_scope?(node = T.unsafe(nil)); end
   def method_name; end
   def non_bare_access_modifier?; end
-  def non_bare_access_modifier_declaration?(node = _); end
+  def non_bare_access_modifier_declaration?(node = T.unsafe(nil)); end
   def receiver; end
   def safe_navigation?; end
   def self_receiver?; end
@@ -487,12 +508,17 @@ class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node
   def identifier; end
 end
 
+class RuboCop::AST::NextNode < ::RuboCop::AST::Node
+  include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
+end
+
 class RuboCop::AST::Node < ::Parser::AST::Node
   include(::RuboCop::AST::Sexp)
   include(::RuboCop::RSpec::Node)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def initialize(type, children = _, properties = _); end
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
 
   def __ENCODING___type?; end
   def __FILE___type?; end
@@ -510,7 +536,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def array_pattern_with_tail_type?; end
   def array_type?; end
   def assignment?; end
-  def assignment_or_similar?(node = _); end
+  def assignment_or_similar?(node = T.unsafe(nil)); end
   def back_ref_type?; end
   def basic_conditional?; end
   def basic_literal?; end
@@ -528,8 +554,8 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def cbase_type?; end
   def chained?; end
   def child_nodes; end
-  def class_constructor?(node = _); end
-  def class_definition?(node = _); end
+  def class_constructor?(node = T.unsafe(nil)); end
+  def class_definition?(node = T.unsafe(nil)); end
   def class_type?; end
   def complete!; end
   def complete?; end
@@ -570,7 +596,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def forward_arg_type?; end
   def forward_args_type?; end
   def forwarded_args_type?; end
-  def global_const?(node = _, param1); end
+  def global_const?(node = T.unsafe(nil), param1); end
   def guard_clause?; end
   def gvar_type?; end
   def gvasgn_type?; end
@@ -596,8 +622,8 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def kwoptarg_type?; end
   def kwrestarg_type?; end
   def kwsplat_type?; end
-  def lambda?(node = _); end
-  def lambda_or_proc?(node = _); end
+  def lambda?(node = T.unsafe(nil)); end
+  def lambda_or_proc?(node = T.unsafe(nil)); end
   def lambda_type?; end
   def last_line; end
   def line_count; end
@@ -609,19 +635,19 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def match_alt_type?; end
   def match_as_type?; end
   def match_current_line_type?; end
-  def match_guard_clause?(node = _); end
+  def match_guard_clause?(node = T.unsafe(nil)); end
   def match_nil_pattern_type?; end
   def match_rest_type?; end
   def match_var_type?; end
   def match_with_lvasgn_type?; end
   def match_with_trailing_comma_type?; end
   def mlhs_type?; end
-  def module_definition?(node = _); end
+  def module_definition?(node = T.unsafe(nil)); end
   def module_type?; end
   def mrasgn_type?; end
   def multiline?; end
   def mutable_literal?; end
-  def new_class_or_module_block?(node = _); end
+  def new_class_or_module_block?(node = T.unsafe(nil)); end
   def next_type?; end
   def nil_type?; end
   def node_parts; end
@@ -647,13 +673,13 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def post_condition_loop?; end
   def postexe_type?; end
   def preexe_type?; end
-  def proc?(node = _); end
+  def proc?(node = T.unsafe(nil)); end
   def procarg0_type?; end
   def pure?; end
   def range_type?; end
   def rasgn_type?; end
   def rational_type?; end
-  def receiver(node = _); end
+  def receiver(node = T.unsafe(nil)); end
   def recursive_basic_literal?; end
   def recursive_literal?; end
   def redo_type?; end
@@ -679,9 +705,9 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def source_range; end
   def special_keyword?; end
   def splat_type?; end
-  def str_content(node = _); end
+  def str_content(node = T.unsafe(nil)); end
   def str_type?; end
-  def struct_constructor?(node = _); end
+  def struct_constructor?(node = T.unsafe(nil)); end
   def super_type?; end
   def sym_type?; end
   def true_type?; end
@@ -690,7 +716,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def unless_guard_type?; end
   def until_post_type?; end
   def until_type?; end
-  def updated(type = _, children = _, properties = _); end
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
   def value_used?; end
   def variable?; end
   def when_type?; end
@@ -709,7 +735,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
 
   def begin_value_used?; end
   def case_if_value_used?; end
-  def defined_module0(node = _); end
+  def defined_module0(node = T.unsafe(nil)); end
   def for_value_used?; end
   def parent_module_name_for_block(ancestor); end
   def parent_module_name_for_sclass(sclass_node); end
@@ -771,7 +797,9 @@ class RuboCop::AST::NodePattern
   def pattern; end
   def to_s; end
 
-  def self.descend(element, &block); end
+  class << self
+    def descend(element, &block); end
+  end
 end
 
 class RuboCop::AST::NodePattern::Invalid < ::StandardError
@@ -806,9 +834,9 @@ class RuboCop::AST::PairNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::HashElementNode)
 
   def colon?; end
-  def delimiter(with_spacing = _); end
+  def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
   def hash_rocket?; end
-  def inverse_delimiter(with_spacing = _); end
+  def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
   def value_on_new_line?; end
 end
 
@@ -830,6 +858,21 @@ module RuboCop::AST::ParameterizedNode
   def splat_argument?; end
 end
 
+module RuboCop::AST::ParameterizedNode::RestArguments
+  include(::RuboCop::AST::ParameterizedNode)
+
+  def arguments; end
+  def arguments?; end
+  def first_argument; end
+  def last_argument; end
+end
+
+module RuboCop::AST::ParameterizedNode::WrappedArguments
+  include(::RuboCop::AST::ParameterizedNode)
+
+  def arguments; end
+end
+
 module RuboCop::AST::PredicateOperatorNode
   def logical_operator?; end
   def operator; end
@@ -847,7 +890,7 @@ RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String)
 class RuboCop::AST::ProcessedSource
   include(::RuboCop::Ext::ProcessedSource)
 
-  def initialize(source, ruby_version, path = _); end
+  def initialize(source, ruby_version, path = T.unsafe(nil)); end
 
   def [](*args); end
   def ast; end
@@ -855,17 +898,19 @@ class RuboCop::AST::ProcessedSource
   def blank?; end
   def buffer; end
   def checksum; end
+  def comment_at_line(line); end
   def commented?(source_range); end
   def comments; end
   def comments_before_line(line); end
   def contains_comment?(source_range); end
   def current_line(token); end
   def diagnostics; end
-  def each_comment; end
-  def each_token; end
+  def each_comment(&block); end
+  def each_comment_in_lines(line_range); end
+  def each_token(&block); end
   def file_path; end
-  def find_comment; end
-  def find_token; end
+  def find_comment(&block); end
+  def find_token(&block); end
   def following_line(token); end
   def line_indentation(line_number); end
   def line_with_comment?(line); end
@@ -881,13 +926,15 @@ class RuboCop::AST::ProcessedSource
 
   private
 
-  def comment_lines; end
+  def comment_index; end
   def create_parser(ruby_version); end
   def parse(source, ruby_version); end
   def parser_class(ruby_version); end
   def tokenize(parser); end
 
-  def self.from_file(path, ruby_version); end
+  class << self
+    def from_file(path, ruby_version); end
+  end
 end
 
 RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String)
@@ -924,20 +971,9 @@ class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node
   def exception_variable; end
 end
 
-class RuboCop::AST::RetryNode < ::RuboCop::AST::Node
-  include(::RuboCop::AST::MethodIdentifierPredicates)
-  include(::RuboCop::AST::MethodDispatchNode)
-  include(::RuboCop::AST::ParameterizedNode)
-
-  def arguments; end
-end
-
 class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
-  include(::RuboCop::AST::MethodIdentifierPredicates)
-  include(::RuboCop::AST::MethodDispatchNode)
   include(::RuboCop::AST::ParameterizedNode)
-
-  def arguments; end
+  include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
 end
 
 class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node
@@ -947,10 +983,15 @@ end
 
 class RuboCop::AST::SendNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::RestArguments)
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
-  def attribute_accessor?(node = _); end
+  def attribute_accessor?(node = T.unsafe(nil)); end
+
+  private
+
+  def first_argument_index; end
 end
 
 module RuboCop::AST::Sexp
@@ -968,6 +1009,7 @@ class RuboCop::AST::SuperNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
+  def arguments; end
   def node_parts; end
 end
 
@@ -1004,7 +1046,9 @@ class RuboCop::AST::Token
   def to_s; end
   def type; end
 
-  def self.from_parser_token(parser_token); end
+  class << self
+    def from_parser_token(parser_token); end
+  end
 end
 
 module RuboCop::AST::Traversal
@@ -1156,7 +1200,7 @@ class RuboCop::AST::WhenNode < ::RuboCop::AST::Node
   def body; end
   def branch_index; end
   def conditions; end
-  def each_condition; end
+  def each_condition(&block); end
   def then?; end
 end
 
@@ -1174,6 +1218,7 @@ class RuboCop::AST::YieldNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
+  def arguments; end
   def node_parts; end
 end
 
@@ -1189,6 +1234,8 @@ RuboCop::AST::NodePattern::Compiler::CAPTURED_REST = T.let(T.unsafe(nil), String
 
 RuboCop::AST::NodePattern::Compiler::CLOSING = T.let(T.unsafe(nil), Regexp)
 
+RuboCop::AST::NodePattern::Compiler::COMMENT = T.let(T.unsafe(nil), Regexp)
+
 RuboCop::AST::NodePattern::Compiler::CONST = T.let(T.unsafe(nil), Regexp)
 
 RuboCop::AST::NodePattern::Compiler::CUR_ELEMENT = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.7.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.7.1.rbi
index 583f91b0e8..4a236060aa 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.7.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.7.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop-performance` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -15,7 +16,7 @@ end
 class RuboCop::Cop::Performance::AncestorsInclude < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
-  def ancestors_include_candidate?(node = _); end
+  def ancestors_include_candidate?(node = T.unsafe(nil)); end
   def autocorrect(node); end
   def on_send(node); end
 end
@@ -24,7 +25,7 @@ RuboCop::Cop::Performance::AncestorsInclude::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::BigDecimalWithNumericArgument < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def big_decimal_with_numeric_argument?(node = _); end
+  def big_decimal_with_numeric_argument?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -39,7 +40,7 @@ class RuboCop::Cop::Performance::BindCall < ::RuboCop::Cop::Cop
   extend(::RuboCop::Cop::TargetRubyVersion)
 
   def autocorrect(node); end
-  def bind_with_call_method?(node = _); end
+  def bind_with_call_method?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -52,9 +53,9 @@ end
 RuboCop::Cop::Performance::BindCall::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::Caller < ::RuboCop::Cop::Cop
-  def caller_with_scope_method?(node = _); end
+  def caller_with_scope_method?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def slow_caller?(node = _); end
+  def slow_caller?(node = T.unsafe(nil)); end
 
   private
 
@@ -94,9 +95,9 @@ RuboCop::Cop::Performance::CaseWhenSplat::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::Casecmp < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def downcase_downcase(node = _); end
-  def downcase_eq(node = _); end
-  def eq_downcase(node = _); end
+  def downcase_downcase(node = T.unsafe(nil)); end
+  def downcase_eq(node = T.unsafe(nil)); end
+  def eq_downcase(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -113,7 +114,7 @@ RuboCop::Cop::Performance::Casecmp::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Performance::ChainArrayAllocation < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
-  def flat_map_candidate?(node = _); end
+  def flat_map_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -131,9 +132,9 @@ class RuboCop::Cop::Performance::CompareWithBlock < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def compare?(node = _); end
+  def compare?(node = T.unsafe(nil)); end
   def on_block(node); end
-  def replaceable_body?(node = _, param1, param2); end
+  def replaceable_body?(node = T.unsafe(nil), param1, param2); end
 
   private
 
@@ -148,7 +149,7 @@ class RuboCop::Cop::Performance::Count < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def count_candidate?(node = _); end
+  def count_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -164,7 +165,7 @@ class RuboCop::Cop::Performance::DeletePrefix < ::RuboCop::Cop::Cop
   extend(::RuboCop::Cop::TargetRubyVersion)
 
   def autocorrect(node); end
-  def delete_prefix_candidate?(node = _); end
+  def delete_prefix_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -177,7 +178,7 @@ class RuboCop::Cop::Performance::DeleteSuffix < ::RuboCop::Cop::Cop
   extend(::RuboCop::Cop::TargetRubyVersion)
 
   def autocorrect(node); end
-  def delete_suffix_candidate?(node = _); end
+  def delete_suffix_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -187,7 +188,7 @@ RuboCop::Cop::Performance::DeleteSuffix::PREFERRED_METHODS = T.let(T.unsafe(nil)
 
 class RuboCop::Cop::Performance::Detect < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def detect_candidate?(node = _); end
+  def detect_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -204,9 +205,9 @@ RuboCop::Cop::Performance::Detect::REVERSE_MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::DoubleStartEndWith < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def check_with_active_support_aliases(node = _); end
+  def check_with_active_support_aliases(node = T.unsafe(nil)); end
   def on_or(node); end
-  def two_start_end_with_calls(node = _); end
+  def two_start_end_with_calls(node = T.unsafe(nil)); end
 
   private
 
@@ -224,13 +225,13 @@ class RuboCop::Cop::Performance::EndWith < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_match_with_lvasgn(node); end
   def on_send(node); end
-  def redundant_regex?(node = _); end
+  def redundant_regex?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::EndWith::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::FixedSize < ::RuboCop::Cop::Cop
-  def counter(node = _); end
+  def counter(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -249,7 +250,7 @@ class RuboCop::Cop::Performance::FlatMap < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def flat_map_candidate?(node = _); end
+  def flat_map_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -265,7 +266,7 @@ RuboCop::Cop::Performance::FlatMap::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::InefficientHashSearch < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def inefficient_include?(node = _); end
+  def inefficient_include?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -283,8 +284,8 @@ class RuboCop::Cop::Performance::IoReadlines < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def readlines_on_class?(node = _); end
-  def readlines_on_instance?(node = _); end
+  def readlines_on_class?(node = T.unsafe(nil)); end
+  def readlines_on_instance?(node = T.unsafe(nil)); end
 
   private
 
@@ -303,7 +304,7 @@ RuboCop::Cop::Performance::IoReadlines::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::OpenStruct < ::RuboCop::Cop::Cop
   def on_send(node); end
-  def open_struct(node = _); end
+  def open_struct(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::OpenStruct::MSG = T.let(T.unsafe(nil), String)
@@ -311,7 +312,7 @@ RuboCop::Cop::Performance::OpenStruct::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Performance::RangeInclude < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def range_include(node = _); end
+  def range_include(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::RangeInclude::MSG = T.let(T.unsafe(nil), String)
@@ -320,7 +321,7 @@ class RuboCop::Cop::Performance::RedundantBlockCall < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def blockarg_assigned?(node0, param1); end
   def blockarg_calls(node0, param1); end
-  def blockarg_def(node = _); end
+  def blockarg_def(node = T.unsafe(nil)); end
   def on_def(node); end
 
   private
@@ -341,18 +342,18 @@ RuboCop::Cop::Performance::RedundantBlockCall::YIELD = T.let(T.unsafe(nil), Stri
 
 class RuboCop::Cop::Performance::RedundantMatch < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def match_call?(node = _); end
+  def match_call?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def only_truthiness_matters?(node = _); end
+  def only_truthiness_matters?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::RedundantMatch::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::RedundantMerge < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def modifier_flow_control?(node = _); end
+  def modifier_flow_control?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def redundant_merge_candidate(node = _); end
+  def redundant_merge_candidate(node = T.unsafe(nil)); end
 
   private
 
@@ -378,7 +379,7 @@ class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector
 
   def initialize(node, receiver); end
 
-  def each_with_object_node(node = _); end
+  def each_with_object_node(node = T.unsafe(nil)); end
   def value_used?; end
 
   private
@@ -413,7 +414,7 @@ class RuboCop::Cop::Performance::RedundantStringChars < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def redundant_chars_call?(node = _); end
+  def redundant_chars_call?(node = T.unsafe(nil)); end
 
   private
 
@@ -433,11 +434,11 @@ RuboCop::Cop::Performance::RedundantStringChars::REPLACEABLE_METHODS = T.let(T.u
 class RuboCop::Cop::Performance::RegexpMatch < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def last_matches(node0); end
-  def match_method?(node = _); end
-  def match_node?(node = _); end
-  def match_operator?(node = _); end
-  def match_threequals?(node = _); end
-  def match_with_int_arg_method?(node = _); end
+  def match_method?(node = T.unsafe(nil)); end
+  def match_node?(node = T.unsafe(nil)); end
+  def match_operator?(node = T.unsafe(nil)); end
+  def match_threequals?(node = T.unsafe(nil)); end
+  def match_with_int_arg_method?(node = T.unsafe(nil)); end
   def match_with_lvasgn?(node); end
   def on_case(node); end
   def on_if(node); end
@@ -446,7 +447,7 @@ class RuboCop::Cop::Performance::RegexpMatch < ::RuboCop::Cop::Cop
   private
 
   def check_condition(cond); end
-  def correct_operator(corrector, recv, arg, oper = _); end
+  def correct_operator(corrector, recv, arg, oper = T.unsafe(nil)); end
   def correction_range(recv, arg); end
   def find_last_match(body, range, scope_root); end
   def last_match_used?(match_node); end
@@ -472,7 +473,7 @@ class RuboCop::Cop::Performance::ReverseEach < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def reverse_each?(node = _); end
+  def reverse_each?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::ReverseEach::MSG = T.let(T.unsafe(nil), String)
@@ -484,7 +485,7 @@ class RuboCop::Cop::Performance::ReverseFirst < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def reverse_first_candidate?(node = _); end
+  def reverse_first_candidate?(node = T.unsafe(nil)); end
 
   private
 
@@ -497,10 +498,10 @@ end
 RuboCop::Cop::Performance::ReverseFirst::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::Size < ::RuboCop::Cop::Cop
-  def array?(node = _); end
+  def array?(node = T.unsafe(nil)); end
   def autocorrect(node); end
-  def count?(node = _); end
-  def hash?(node = _); end
+  def count?(node = T.unsafe(nil)); end
+  def hash?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -523,7 +524,7 @@ RuboCop::Cop::Performance::SortReverse::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Performance::Squeeze < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def squeeze_candidate?(node = _); end
+  def squeeze_candidate?(node = T.unsafe(nil)); end
 
   private
 
@@ -540,7 +541,7 @@ class RuboCop::Cop::Performance::StartWith < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_match_with_lvasgn(node); end
   def on_send(node); end
-  def redundant_regex?(node = _); end
+  def redundant_regex?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::StartWith::MSG = T.let(T.unsafe(nil), String)
@@ -549,7 +550,7 @@ class RuboCop::Cop::Performance::StringInclude < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_match_with_lvasgn(node); end
   def on_send(node); end
-  def redundant_regex?(node = _); end
+  def redundant_regex?(node = T.unsafe(nil)); end
 
   private
 
@@ -564,7 +565,7 @@ class RuboCop::Cop::Performance::StringReplacement < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
   def replace_method(node, first, second, first_param, replacement); end
-  def string_replacement?(node = _); end
+  def string_replacement?(node = T.unsafe(nil)); end
 
   private
 
@@ -595,7 +596,7 @@ class RuboCop::Cop::Performance::TimesMap < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_block(node); end
   def on_send(node); end
-  def times_map_call(node = _); end
+  def times_map_call(node = T.unsafe(nil)); end
 
   private
 
@@ -608,9 +609,9 @@ RuboCop::Cop::Performance::TimesMap::MESSAGE = T.let(T.unsafe(nil), String)
 RuboCop::Cop::Performance::TimesMap::MESSAGE_ONLY_IF = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::UnfreezeString < ::RuboCop::Cop::Cop
-  def dup_string?(node = _); end
+  def dup_string?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def string_new?(node = _); end
+  def string_new?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::UnfreezeString::MSG = T.let(T.unsafe(nil), String)
@@ -618,7 +619,7 @@ RuboCop::Cop::Performance::UnfreezeString::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Performance::UriDefaultParser < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def uri_parser_new?(node = _); end
+  def uri_parser_new?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::UriDefaultParser::MSG = T.let(T.unsafe(nil), String)
@@ -642,8 +643,8 @@ module RuboCop::Cop::SortBlock
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def replaceable_body?(node = _, param1, param2); end
-  def sort_with_block?(node = _); end
+  def replaceable_body?(node = T.unsafe(nil), param1, param2); end
+  def sort_with_block?(node = T.unsafe(nil)); end
 
   private
 
@@ -658,7 +659,9 @@ end
 RuboCop::Performance::CONFIG = T.let(T.unsafe(nil), Hash)
 
 module RuboCop::Performance::Inject
-  def self.defaults!; end
+  class << self
+    def defaults!; end
+  end
 end
 
 module RuboCop::Performance::Version
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@1.42.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@1.42.0.rbi
index 780df93b35..3698d4acd4 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@1.42.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@1.42.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop-rspec` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -39,7 +40,9 @@ class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Cop
   def ignored_range?(ast, start_pos); end
   def ignored_ranges(ast); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String)
@@ -54,7 +57,9 @@ class RuboCop::Cop::RSpec::AlignLeftLetBrace < ::RuboCop::Cop::RSpec::Cop
 
   def on_new_investigation; end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::RSpec::AlignLeftLetBrace::MSG = T.let(T.unsafe(nil), String)
@@ -64,13 +69,15 @@ class RuboCop::Cop::RSpec::AlignRightLetBrace < ::RuboCop::Cop::RSpec::Cop
 
   def on_new_investigation; end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::RSpec::AlignRightLetBrace::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::AnyInstance < ::RuboCop::Cop::RSpec::Cop
-  def disallowed_stub(node = _); end
+  def disallowed_stub(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -78,7 +85,7 @@ RuboCop::Cop::RSpec::AnyInstance::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::AroundBlock < ::RuboCop::Cop::RSpec::Cop
   def find_arg_usage(node0); end
-  def hook(node = _); end
+  def hook(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -92,7 +99,7 @@ RuboCop::Cop::RSpec::AroundBlock::MSG_NO_ARG = T.let(T.unsafe(nil), String)
 RuboCop::Cop::RSpec::AroundBlock::MSG_UNUSED_ARG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::Be < ::RuboCop::Cop::RSpec::Cop
-  def be_without_args(node = _); end
+  def be_without_args(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -101,14 +108,14 @@ RuboCop::Cop::RSpec::Be::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::BeEql < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def eql_type_with_identity(node = _); end
+  def eql_type_with_identity(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
 RuboCop::Cop::RSpec::BeEql::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::BeforeAfterAll < ::RuboCop::Cop::RSpec::Cop
-  def before_or_after_all(node = _); end
+  def before_or_after_all(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -120,10 +127,10 @@ end
 class RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def as_is_matcher(node = _); end
-  def expectation_set_on_current_path(node = _); end
+  def as_is_matcher(node = T.unsafe(nil)); end
+  def expectation_set_on_current_path(node = T.unsafe(nil)); end
   def on_send(node); end
-  def regexp_str_matcher(node = _); end
+  def regexp_str_matcher(node = T.unsafe(nil)); end
 
   private
 
@@ -138,10 +145,10 @@ RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::MSG = T.let(T.unsafe(nil)
 class RuboCop::Cop::RSpec::Capybara::FeatureMethods < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def feature_method(node = _); end
+  def feature_method(node = T.unsafe(nil)); end
   def message(range); end
   def on_block(node); end
-  def spec?(node = _); end
+  def spec?(node = T.unsafe(nil)); end
 
   private
 
@@ -158,8 +165,8 @@ RuboCop::Cop::RSpec::Capybara::FeatureMethods::MSG = T.let(T.unsafe(nil), String
 
 class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher < ::RuboCop::Cop::RSpec::Cop
   def on_send(node); end
-  def visible_false?(node = _); end
-  def visible_true?(node = _); end
+  def visible_false?(node = T.unsafe(nil)); end
+  def visible_true?(node = T.unsafe(nil)); end
 
   private
 
@@ -175,7 +182,7 @@ RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::MSG_TRUE = T.let(T.unsafe(nil)
 class RuboCop::Cop::RSpec::ContextMethod < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def context_method(node = _); end
+  def context_method(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -186,7 +193,7 @@ end
 RuboCop::Cop::RSpec::ContextMethod::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::ContextWording < ::RuboCop::Cop::RSpec::Cop
-  def context_wording(node = _); end
+  def context_wording(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -212,7 +219,9 @@ class RuboCop::Cop::RSpec::Cop < ::RuboCop::Cop::Base
   def rspec_pattern_config; end
   def rspec_pattern_config?; end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 RuboCop::Cop::RSpec::Cop::DEFAULT_CONFIGURATION = T.let(T.unsafe(nil), Hash)
@@ -222,10 +231,10 @@ RuboCop::Cop::RSpec::Cop::DEFAULT_PATTERN_RE = T.let(T.unsafe(nil), Regexp)
 class RuboCop::Cop::RSpec::DescribeClass < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::RSpec::TopLevelDescribe)
 
-  def describe_with_rails_metadata?(node = _); end
+  def describe_with_rails_metadata?(node = T.unsafe(nil)); end
   def on_top_level_describe(node, _); end
-  def rails_metadata?(node = _); end
-  def valid_describe?(node = _); end
+  def rails_metadata?(node = T.unsafe(nil)); end
+  def valid_describe?(node = T.unsafe(nil)); end
 
   private
 
@@ -243,7 +252,7 @@ end
 RuboCop::Cop::RSpec::DescribeMethod::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::DescribeSymbol < ::RuboCop::Cop::RSpec::Cop
-  def describe_symbol?(node = _); end
+  def describe_symbol?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -253,12 +262,12 @@ class RuboCop::Cop::RSpec::DescribedClass < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def common_instance_exec_closure?(node = _); end
+  def common_instance_exec_closure?(node = T.unsafe(nil)); end
   def contains_described_class?(node0); end
-  def described_constant(node = _); end
+  def described_constant(node = T.unsafe(nil)); end
   def on_block(node); end
-  def rspec_block?(node = _); end
-  def scope_changing_syntax?(node = _); end
+  def rspec_block?(node = T.unsafe(nil)); end
+  def scope_changing_syntax?(node = T.unsafe(nil)); end
 
   private
 
@@ -292,7 +301,7 @@ class RuboCop::Cop::RSpec::Dialect < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def rspec_method?(node = _); end
+  def rspec_method?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::RSpec::Dialect::MSG = T.let(T.unsafe(nil), String)
@@ -313,7 +322,7 @@ class RuboCop::Cop::RSpec::EmptyHook < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def empty_hook?(node = _); end
+  def empty_hook?(node = T.unsafe(nil)); end
   def on_block(node); end
 end
 
@@ -400,7 +409,7 @@ RuboCop::Cop::RSpec::ExampleLength::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::ExampleWithoutDescription < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def example_description(node = _); end
+  def example_description(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -416,7 +425,7 @@ RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_DEFAULT_ARGUMENT = T.let(T.u
 class RuboCop::Cop::RSpec::ExampleWording < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def it_description(node = _); end
+  def it_description(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -440,7 +449,7 @@ RuboCop::Cop::RSpec::ExampleWording::SHOULD_PREFIX = T.let(T.unsafe(nil), Regexp
 class RuboCop::Cop::RSpec::ExpectActual < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def expect_literal(node = _); end
+  def expect_literal(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -463,8 +472,8 @@ class RuboCop::Cop::RSpec::ExpectChange < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def expect_change_with_arguments(node = _); end
-  def expect_change_with_block(node = _); end
+  def expect_change_with_arguments(node = T.unsafe(nil)); end
+  def expect_change_with_block(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_send(node); end
 end
@@ -498,8 +507,8 @@ module RuboCop::Cop::RSpec::ExplicitHelper
   include(::RuboCop::RSpec::Language)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def predicate_matcher?(node = _); end
-  def predicate_matcher_block?(node = _); end
+  def predicate_matcher?(node = T.unsafe(nil)); end
+  def predicate_matcher_block?(node = T.unsafe(nil)); end
 
   private
 
@@ -523,10 +532,10 @@ end
 class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def association?(node = _); end
-  def factory_attributes(node = _); end
+  def association?(node = T.unsafe(nil)); end
+  def factory_attributes(node = T.unsafe(nil)); end
   def on_block(node); end
-  def value_matcher(node = _); end
+  def value_matcher(node = T.unsafe(nil)); end
 
   private
 
@@ -548,9 +557,9 @@ class RuboCop::Cop::RSpec::FactoryBot::CreateList < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def factory_call(node = _); end
-  def factory_list_call(node = _); end
-  def n_times_block_without_arg?(node = _); end
+  def factory_call(node = T.unsafe(nil)); end
+  def factory_list_call(node = T.unsafe(nil)); end
+  def n_times_block_without_arg?(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_send(node); end
 
@@ -602,7 +611,7 @@ end
 class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def class_name(node = _); end
+  def class_name(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -639,8 +648,8 @@ end
 RuboCop::Cop::RSpec::FilePath::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::Focus < ::RuboCop::Cop::RSpec::Cop
-  def focused_block?(node = _); end
-  def metadata(node = _); end
+  def focused_block?(node = T.unsafe(nil)); end
+  def metadata(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -657,8 +666,8 @@ class RuboCop::Cop::RSpec::HookArgument < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_block(node); end
-  def scoped_hook(node = _); end
-  def unscoped_hook(node = _); end
+  def scoped_hook(node = T.unsafe(nil)); end
+  def unscoped_hook(node = T.unsafe(nil)); end
 
   private
 
@@ -678,7 +687,7 @@ RuboCop::Cop::RSpec::HookArgument::IMPLICIT_MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::HooksBeforeExamples < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def example_or_group?(node = _); end
+  def example_or_group?(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -692,9 +701,9 @@ end
 RuboCop::Cop::RSpec::HooksBeforeExamples::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::ImplicitBlockExpectation < ::RuboCop::Cop::RSpec::Cop
-  def implicit_expect(node = _); end
-  def lambda?(node = _); end
-  def lambda_subject?(node = _); end
+  def implicit_expect(node = T.unsafe(nil)); end
+  def lambda?(node = T.unsafe(nil)); end
+  def lambda_subject?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -710,7 +719,7 @@ class RuboCop::Cop::RSpec::ImplicitExpect < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def implicit_expect(node = _); end
+  def implicit_expect(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -729,7 +738,7 @@ class RuboCop::Cop::RSpec::ImplicitSubject < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def implicit_subject?(node = _); end
+  def implicit_subject?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -745,9 +754,9 @@ module RuboCop::Cop::RSpec::InflectedHelper
   include(::RuboCop::RSpec::Language)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def be_bool?(node = _); end
-  def be_boolthy?(node = _); end
-  def predicate_in_actual?(node = _); end
+  def be_bool?(node = T.unsafe(nil)); end
+  def be_boolthy?(node = T.unsafe(nil)); end
+  def predicate_in_actual?(node = T.unsafe(nil)); end
 
   private
 
@@ -780,8 +789,8 @@ RuboCop::Cop::RSpec::InstanceSpy::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::InstanceVariable < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::RSpec::TopLevelGroup)
 
-  def custom_matcher?(node = _); end
-  def dynamic_class?(node = _); end
+  def custom_matcher?(node = T.unsafe(nil)); end
+  def dynamic_class?(node = T.unsafe(nil)); end
   def ivar_assigned?(node0, param1); end
   def ivar_usage(node0); end
   def on_top_level_group(node); end
@@ -795,7 +804,7 @@ end
 RuboCop::Cop::RSpec::InstanceVariable::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::InvalidPredicateMatcher < ::RuboCop::Cop::RSpec::Cop
-  def invalid_predicate_matcher?(node = _); end
+  def invalid_predicate_matcher?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -809,7 +818,7 @@ class RuboCop::Cop::RSpec::ItBehavesLike < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def example_inclusion_offense(node = _, param1); end
+  def example_inclusion_offense(node = T.unsafe(nil), param1); end
   def on_send(node); end
 
   private
@@ -820,8 +829,8 @@ end
 RuboCop::Cop::RSpec::ItBehavesLike::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::IteratedExpectation < ::RuboCop::Cop::RSpec::Cop
-  def each?(node = _); end
-  def expectation?(node = _, param1); end
+  def each?(node = T.unsafe(nil)); end
+  def expectation?(node = T.unsafe(nil), param1); end
   def on_block(node); end
 
   private
@@ -867,7 +876,7 @@ RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_MODULE = T.let(T.unsafe(nil),
 class RuboCop::Cop::RSpec::LetBeforeExamples < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def example_or_group?(node = _); end
+  def example_or_group?(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -881,8 +890,8 @@ end
 RuboCop::Cop::RSpec::LetBeforeExamples::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::LetSetup < ::RuboCop::Cop::RSpec::Cop
-  def example_or_shared_group_or_including?(node = _); end
-  def let_bang(node = _); end
+  def example_or_shared_group_or_including?(node = T.unsafe(nil)); end
+  def let_bang(node = T.unsafe(nil)); end
   def method_called?(node0, param1); end
   def on_block(node); end
 
@@ -895,7 +904,7 @@ end
 RuboCop::Cop::RSpec::LetSetup::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::MessageChain < ::RuboCop::Cop::RSpec::Cop
-  def message_chain(node = _); end
+  def message_chain(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -904,7 +913,7 @@ RuboCop::Cop::RSpec::MessageChain::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::MessageExpectation < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def message_expectation(node = _); end
+  def message_expectation(node = T.unsafe(nil)); end
   def on_send(node); end
   def receive_message?(node0); end
 
@@ -920,7 +929,7 @@ RuboCop::Cop::RSpec::MessageExpectation::SUPPORTED_STYLES = T.let(T.unsafe(nil),
 class RuboCop::Cop::RSpec::MessageSpies < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def message_expectation(node = _); end
+  def message_expectation(node = T.unsafe(nil)); end
   def on_send(node); end
   def receive_message(node0); end
 
@@ -954,10 +963,10 @@ RuboCop::Cop::RSpec::MultipleDescribes::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::MultipleExpectations < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableMax)
 
-  def aggregate_failures?(node = _); end
-  def aggregate_failures_block?(node = _); end
-  def aggregate_failures_present?(node = _); end
-  def expect?(node = _); end
+  def aggregate_failures?(node = T.unsafe(nil)); end
+  def aggregate_failures_block?(node = T.unsafe(nil)); end
+  def aggregate_failures_present?(node = T.unsafe(nil)); end
+  def expect?(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -990,8 +999,8 @@ RuboCop::Cop::RSpec::MultipleSubjects::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::NamedSubject < ::RuboCop::Cop::RSpec::Cop
   def ignored_shared_example?(node); end
   def on_block(node); end
-  def rspec_block?(node = _); end
-  def shared_example?(node = _); end
+  def rspec_block?(node = T.unsafe(nil)); end
+  def shared_example?(node = T.unsafe(nil)); end
   def subject_usage(node0); end
 end
 
@@ -1005,7 +1014,7 @@ class RuboCop::Cop::RSpec::NestedGroups < ::RuboCop::Cop::RSpec::Cop
 
   private
 
-  def find_nested_example_groups(node, nesting: _, &block); end
+  def find_nested_example_groups(node, nesting: T.unsafe(nil), &block); end
   def max_nesting; end
   def max_nesting_config; end
   def message(nesting); end
@@ -1021,7 +1030,7 @@ class RuboCop::Cop::RSpec::NotToNot < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def not_to_not_offense(node = _, param1); end
+  def not_to_not_offense(node = T.unsafe(nil), param1); end
   def on_send(node); end
 
   private
@@ -1032,9 +1041,9 @@ end
 RuboCop::Cop::RSpec::NotToNot::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::OverwritingSetup < ::RuboCop::Cop::RSpec::Cop
-  def first_argument_name(node = _); end
+  def first_argument_name(node = T.unsafe(nil)); end
   def on_block(node); end
-  def setup?(node = _); end
+  def setup?(node = T.unsafe(nil)); end
 
   private
 
@@ -1046,10 +1055,10 @@ RuboCop::Cop::RSpec::OverwritingSetup::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::Pending < ::RuboCop::Cop::RSpec::Cop
   def on_send(node); end
-  def pending_block?(node = _); end
-  def skip_or_pending?(node = _); end
-  def skippable?(node = _); end
-  def skipped_in_metadata?(node = _); end
+  def pending_block?(node = T.unsafe(nil)); end
+  def skip_or_pending?(node = T.unsafe(nil)); end
+  def skippable?(node = T.unsafe(nil)); end
+  def skipped_in_metadata?(node = T.unsafe(nil)); end
 
   private
 
@@ -1082,7 +1091,7 @@ class RuboCop::Cop::RSpec::ReceiveCounts < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def receive_counts(node = _); end
+  def receive_counts(node = T.unsafe(nil)); end
   def stub?(node0); end
 
   private
@@ -1131,12 +1140,12 @@ end
 RuboCop::Cop::RSpec::RepeatedExample::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < ::RuboCop::Cop::RSpec::Cop
-  def body(node = _); end
-  def const_arg(node = _); end
-  def metadata(node = _); end
+  def body(node = T.unsafe(nil)); end
+  def const_arg(node = T.unsafe(nil)); end
+  def metadata(node = T.unsafe(nil)); end
   def on_begin(node); end
-  def several_example_groups?(node = _); end
-  def skip_or_pending?(node = _); end
+  def several_example_groups?(node = T.unsafe(nil)); end
+  def skip_or_pending?(node = T.unsafe(nil)); end
 
   private
 
@@ -1149,11 +1158,11 @@ end
 RuboCop::Cop::RSpec::RepeatedExampleGroupBody::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < ::RuboCop::Cop::RSpec::Cop
-  def doc_string_and_metadata(node = _); end
-  def empty_description?(node = _); end
+  def doc_string_and_metadata(node = T.unsafe(nil)); end
+  def empty_description?(node = T.unsafe(nil)); end
   def on_begin(node); end
-  def several_example_groups?(node = _); end
-  def skip_or_pending?(node = _); end
+  def several_example_groups?(node = T.unsafe(nil)); end
+  def skip_or_pending?(node = T.unsafe(nil)); end
 
   private
 
@@ -1172,7 +1181,7 @@ class RuboCop::Cop::RSpec::ReturnFromStub < ::RuboCop::Cop::RSpec::Cop
   def contains_stub?(node0); end
   def on_block(node); end
   def on_send(node); end
-  def stub_with_block?(node = _); end
+  def stub_with_block?(node = T.unsafe(nil)); end
 
   private
 
@@ -1243,8 +1252,8 @@ class RuboCop::Cop::RSpec::SharedContext < ::RuboCop::Cop::RSpec::Cop
   def context?(node0); end
   def examples?(node0); end
   def on_block(node); end
-  def shared_context(node = _); end
-  def shared_example(node = _); end
+  def shared_context(node = T.unsafe(nil)); end
+  def shared_example(node = T.unsafe(nil)); end
 
   private
 
@@ -1260,7 +1269,7 @@ class RuboCop::Cop::RSpec::SharedExamples < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def shared_examples(node = _); end
+  def shared_examples(node = T.unsafe(nil)); end
 end
 
 class RuboCop::Cop::RSpec::SharedExamples::Checker
@@ -1281,9 +1290,9 @@ RuboCop::Cop::RSpec::SharedExamples::Checker::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::SingleArgumentMessageChain < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def message_chain(node = _); end
+  def message_chain(node = T.unsafe(nil)); end
   def on_send(node); end
-  def single_key_hash?(node = _); end
+  def single_key_hash?(node = T.unsafe(nil)); end
 
   private
 
@@ -1301,15 +1310,15 @@ RuboCop::Cop::RSpec::SingleArgumentMessageChain::MSG = T.let(T.unsafe(nil), Stri
 class RuboCop::Cop::RSpec::SubjectStub < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::RSpec::TopLevelGroup)
 
-  def message_expectation?(node = _, param1); end
+  def message_expectation?(node = T.unsafe(nil), param1); end
   def message_expectation_matcher?(node0); end
   def on_top_level_group(node); end
-  def subject(node = _); end
+  def subject(node = T.unsafe(nil)); end
 
   private
 
   def find_all_explicit_subjects(node); end
-  def find_subject_expectations(node, subject_names = _, &block); end
+  def find_subject_expectations(node, subject_names = T.unsafe(nil), &block); end
 end
 
 RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String)
@@ -1317,7 +1326,7 @@ RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::UnspecifiedException < ::RuboCop::Cop::RSpec::Cop
   def block_with_args?(node); end
   def empty_exception_matcher?(node); end
-  def empty_raise_error_or_exception(node = _); end
+  def empty_raise_error_or_exception(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -1355,7 +1364,7 @@ RuboCop::Cop::RSpec::VariableName::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::VerifiedDoubles < ::RuboCop::Cop::RSpec::Cop
   def on_send(node); end
-  def unverified_double(node = _); end
+  def unverified_double(node = T.unsafe(nil)); end
 
   private
 
@@ -1365,8 +1374,8 @@ end
 RuboCop::Cop::RSpec::VerifiedDoubles::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::VoidExpect < ::RuboCop::Cop::RSpec::Cop
-  def expect?(node = _); end
-  def expect_block?(node = _); end
+  def expect?(node = T.unsafe(nil)); end
+  def expect_block?(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_send(node); end
 
@@ -1382,8 +1391,8 @@ class RuboCop::Cop::RSpec::Yield < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def block_arg(node = _); end
-  def block_call?(node = _, param1); end
+  def block_arg(node = T.unsafe(nil)); end
+  def block_call?(node = T.unsafe(nil), param1); end
   def method_on_stub?(node0); end
   def on_block(node); end
 
@@ -1477,9 +1486,9 @@ end
 class RuboCop::RSpec::Example < ::RuboCop::RSpec::Concept
   def definition; end
   def doc_string; end
-  def extract_doc_string(node = _); end
-  def extract_implementation(node = _); end
-  def extract_metadata(node = _); end
+  def extract_doc_string(node = T.unsafe(nil)); end
+  def extract_implementation(node = T.unsafe(nil)); end
+  def extract_metadata(node = T.unsafe(nil)); end
   def implementation; end
   def metadata; end
 end
@@ -1488,7 +1497,7 @@ class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept
   def examples; end
   def hooks; end
   def lets; end
-  def scope_change?(node = _); end
+  def scope_change?(node = T.unsafe(nil)); end
   def subjects; end
 
   private
@@ -1498,8 +1507,10 @@ class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept
 end
 
 module RuboCop::RSpec::FactoryBot
-  def self.attribute_defining_methods; end
-  def self.reserved_methods; end
+  class << self
+    def attribute_defining_methods; end
+    def reserved_methods; end
+  end
 end
 
 module RuboCop::RSpec::FinalEndLocation
@@ -1508,7 +1519,7 @@ end
 
 class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept
   def example?; end
-  def extract_metadata(node = _); end
+  def extract_metadata(node = T.unsafe(nil)); end
   def knowable_scope?; end
   def metadata; end
   def name; end
@@ -1524,7 +1535,9 @@ class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept
 end
 
 module RuboCop::RSpec::Inject
-  def self.defaults!; end
+  class << self
+    def defaults!; end
+  end
 end
 
 module RuboCop::RSpec::Language
@@ -1588,14 +1601,14 @@ RuboCop::RSpec::Language::Includes::EXAMPLES = T.let(T.unsafe(nil), RuboCop::RSp
 module RuboCop::RSpec::Language::NodePattern
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def example?(node = _); end
-  def example_group?(node = _); end
-  def example_group_with_body?(node = _); end
-  def hook?(node = _); end
-  def let?(node = _); end
-  def shared_group?(node = _); end
-  def spec_group?(node = _); end
-  def subject?(node = _); end
+  def example?(node = T.unsafe(nil)); end
+  def example_group?(node = T.unsafe(nil)); end
+  def example_group_with_body?(node = T.unsafe(nil)); end
+  def hook?(node = T.unsafe(nil)); end
+  def let?(node = T.unsafe(nil)); end
+  def shared_group?(node = T.unsafe(nil)); end
+  def spec_group?(node = T.unsafe(nil)); end
+  def subject?(node = T.unsafe(nil)); end
 end
 
 RuboCop::RSpec::Language::RSPEC = T.let(T.unsafe(nil), String)
@@ -1659,7 +1672,7 @@ module RuboCop::RSpec::TopLevelGroup
   include(::RuboCop::RSpec::Language)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def example_or_shared_group?(node = _); end
+  def example_or_shared_group?(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -1674,7 +1687,7 @@ module RuboCop::RSpec::Variable
   include(::RuboCop::RSpec::Language)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def variable_definition?(node = _); end
+  def variable_definition?(node = T.unsafe(nil)); end
 end
 
 module RuboCop::RSpec::Version
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@0.88.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@0.88.0.rbi
index defd5528c7..f96d50aef1 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop@0.88.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop@0.88.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -11,7 +12,7 @@ class RuboCop::CLI
 
   def config_store; end
   def options; end
-  def run(args = _); end
+  def run(args = T.unsafe(nil)); end
 
   private
 
@@ -25,7 +26,13 @@ class RuboCop::CLI
 end
 
 module RuboCop::CLI::Command
-  def self.run(env, name); end
+  class << self
+    def run(env, name); end
+
+    private
+
+    def class_for(name); end
+  end
 end
 
 class RuboCop::CLI::Command::AutoGenerateConfig < ::RuboCop::CLI::Command::Base
@@ -64,10 +71,12 @@ class RuboCop::CLI::Command::Base
 
   def env; end
 
-  def self.by_command_name(name); end
-  def self.command_name; end
-  def self.command_name=(_); end
-  def self.inherited(subclass); end
+  class << self
+    def by_command_name(name); end
+    def command_name; end
+    def command_name=(_); end
+    def inherited(subclass); end
+  end
 end
 
 class RuboCop::CLI::Command::ExecuteRunner < ::RuboCop::CLI::Command::Base
@@ -185,10 +194,12 @@ class RuboCop::CommentConfig::CopAnalysis < ::Struct
   def start_line_number; end
   def start_line_number=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 RuboCop::CommentConfig::REDUNDANT_DISABLE = T.let(T.unsafe(nil), String)
@@ -198,7 +209,7 @@ class RuboCop::Config
   include(::RuboCop::FileFinder)
   extend(::Forwardable)
 
-  def initialize(hash = _, loaded_path = _); end
+  def initialize(hash = T.unsafe(nil), loaded_path = T.unsafe(nil)); end
 
   def [](*args, &block); end
   def []=(*args, &block); end
@@ -247,7 +258,9 @@ class RuboCop::Config
   def read_rails_version_from_bundler_lock_file; end
   def target_rails_version_from_bundler_lock_file; end
 
-  def self.create(hash, path); end
+  class << self
+    def create(hash, path); end
+  end
 end
 
 class RuboCop::Config::CopConfig < ::Struct
@@ -256,10 +269,12 @@ class RuboCop::Config::CopConfig < ::Struct
   def name; end
   def name=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 RuboCop::Config::DEFAULT_RAILS_VERSION = T.let(T.unsafe(nil), Float)
@@ -267,31 +282,45 @@ RuboCop::Config::DEFAULT_RAILS_VERSION = T.let(T.unsafe(nil), Float)
 class RuboCop::ConfigLoader
   extend(::RuboCop::FileFinder)
 
-  def self.add_excludes_from_files(config, config_file); end
-  def self.add_missing_namespaces(path, hash); end
-  def self.clear_options; end
-  def self.configuration_file_for(target_dir); end
-  def self.configuration_from_file(config_file); end
-  def self.debug; end
-  def self.debug=(_); end
-  def self.debug?; end
-  def self.default_configuration; end
-  def self.default_configuration=(_); end
-  def self.disable_pending_cops; end
-  def self.disable_pending_cops=(_); end
-  def self.enable_pending_cops; end
-  def self.enable_pending_cops=(_); end
-  def self.ignore_parent_exclusion; end
-  def self.ignore_parent_exclusion=(_); end
-  def self.ignore_parent_exclusion?; end
-  def self.load_file(file); end
-  def self.load_yaml_configuration(absolute_path); end
-  def self.merge(base_hash, derived_hash); end
-  def self.merge_with_default(config, config_file, unset_nil: _); end
-  def self.possible_new_cops?(config); end
-  def self.project_root; end
-  def self.project_root=(_); end
-  def self.warn_on_pending_cops(pending_cops); end
+  class << self
+    def add_excludes_from_files(config, config_file); end
+    def add_missing_namespaces(path, hash); end
+    def clear_options; end
+    def configuration_file_for(target_dir); end
+    def configuration_from_file(config_file); end
+    def debug; end
+    def debug=(_); end
+    def debug?; end
+    def default_configuration; end
+    def default_configuration=(_); end
+    def disable_pending_cops; end
+    def disable_pending_cops=(_); end
+    def enable_pending_cops; end
+    def enable_pending_cops=(_); end
+    def ignore_parent_exclusion; end
+    def ignore_parent_exclusion=(_); end
+    def ignore_parent_exclusion?; end
+    def load_file(file); end
+    def load_yaml_configuration(absolute_path); end
+    def merge(base_hash, derived_hash); end
+    def merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end
+    def possible_new_cops?(config); end
+    def project_root; end
+    def project_root=(_); end
+    def warn_on_pending_cops(pending_cops); end
+
+    private
+
+    def check_duplication(yaml_code, absolute_path); end
+    def expand_path(path); end
+    def find_project_dotfile(target_dir); end
+    def find_project_root; end
+    def find_user_dotfile; end
+    def find_user_xdg_config; end
+    def read_file(absolute_path); end
+    def resolver; end
+    def yaml_safe_load(yaml_code, filename); end
+  end
 end
 
 RuboCop::ConfigLoader::DEFAULT_FILE = T.let(T.unsafe(nil), String)
@@ -384,7 +413,7 @@ class RuboCop::ConfigValidator
   private
 
   def alert_about_unrecognized_cops(invalid_cop_names); end
-  def check_cop_config_value(hash, parent = _); end
+  def check_cop_config_value(hash, parent = T.unsafe(nil)); end
   def check_target_ruby; end
   def each_invalid_parameter(cop_name); end
   def msg_not_boolean(parent, key, value); end
@@ -411,7 +440,7 @@ module RuboCop::Cop::Alignment
 
   private
 
-  def check_alignment(items, base_column = _); end
+  def check_alignment(items, base_column = T.unsafe(nil)); end
   def column_delta; end
   def configured_indentation_width; end
   def display_column(range); end
@@ -428,9 +457,24 @@ class RuboCop::Cop::AlignmentCorrector
   extend(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::Alignment)
 
-  def self.align_end(processed_source, node, align_to); end
-  def self.correct(processed_source, node, column_delta); end
-  def self.processed_source; end
+  class << self
+    def align_end(processed_source, node, align_to); end
+    def correct(processed_source, node, column_delta); end
+    def processed_source; end
+
+    private
+
+    def alignment_column(align_to); end
+    def autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end
+    def block_comment_within?(expr); end
+    def calculate_range(expr, line_begin_pos, column_delta); end
+    def delimited_string_literal?(node); end
+    def each_line(expr); end
+    def inside_string_range(node); end
+    def inside_string_ranges(node); end
+    def remove(range, corrector); end
+    def whitespace_range(node); end
+  end
 end
 
 module RuboCop::Cop::AllowedMethods
@@ -500,8 +544,10 @@ class RuboCop::Cop::Badge
   def to_s; end
   def with_department(department); end
 
-  def self.for(class_name); end
-  def self.parse(identifier); end
+  class << self
+    def for(class_name); end
+    def parse(identifier); end
+  end
 end
 
 class RuboCop::Cop::Badge::InvalidBadge < ::RuboCop::Error
@@ -519,10 +565,10 @@ class RuboCop::Cop::Base
   extend(::RuboCop::AST::Sexp)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def initialize(config = _, options = _); end
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
 
-  def add_global_offense(message = _, severity: _); end
-  def add_offense(node_or_range, message: _, severity: _, &block); end
+  def add_global_offense(message = T.unsafe(nil), severity: T.unsafe(nil)); end
+  def add_offense(node_or_range, message: T.unsafe(nil), severity: T.unsafe(nil), &block); end
   def config; end
   def config_to_allow_offenses; end
   def config_to_allow_offenses=(hash); end
@@ -530,7 +576,7 @@ class RuboCop::Cop::Base
   def cop_name; end
   def excluded_file?(file); end
   def external_dependency_checksum; end
-  def message(_range = _); end
+  def message(_range = T.unsafe(nil)); end
   def name; end
   def offenses; end
   def on_investigation_end; end
@@ -564,17 +610,19 @@ class RuboCop::Cop::Base
   def range_from_node_or_range(node_or_range); end
   def reset_investigation; end
 
-  def self.autocorrect_incompatible_with; end
-  def self.badge; end
-  def self.cop_name; end
-  def self.department; end
-  def self.exclude_from_registry; end
-  def self.inherited(subclass); end
-  def self.joining_forces; end
-  def self.lint?; end
-  def self.match?(given_names); end
-  def self.support_autocorrect?; end
-  def self.support_multiple_source?; end
+  class << self
+    def autocorrect_incompatible_with; end
+    def badge; end
+    def cop_name; end
+    def department; end
+    def exclude_from_registry; end
+    def inherited(subclass); end
+    def joining_forces; end
+    def lint?; end
+    def match?(given_names); end
+    def support_autocorrect?; end
+    def support_multiple_source?; end
+  end
 end
 
 class RuboCop::Cop::Base::InvestigationReport < ::Struct
@@ -587,10 +635,12 @@ class RuboCop::Cop::Base::InvestigationReport < ::Struct
   def processed_source; end
   def processed_source=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 module RuboCop::Cop::Bundler
@@ -613,7 +663,7 @@ RuboCop::Cop::Bundler::DuplicatedGem::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Bundler::GemComment < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::DefNode)
 
-  def gem_declaration?(node = _); end
+  def gem_declaration?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -639,7 +689,7 @@ class RuboCop::Cop::Bundler::InsecureProtocolSource < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def insecure_protocol_source?(node = _); end
+  def insecure_protocol_source?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -676,7 +726,9 @@ module RuboCop::Cop::CheckAssignment
 
   def extract_rhs(node); end
 
-  def self.extract_rhs(node); end
+  class << self
+    def extract_rhs(node); end
+  end
 end
 
 module RuboCop::Cop::CheckLineBreakable
@@ -713,7 +765,7 @@ end
 class RuboCop::Cop::Commissioner
   include(::RuboCop::AST::Traversal)
 
-  def initialize(cops, forces = _, options = _); end
+  def initialize(cops, forces = T.unsafe(nil), options = T.unsafe(nil)); end
 
   def errors; end
   def investigate(processed_source); end
@@ -842,7 +894,7 @@ class RuboCop::Cop::Commissioner
   def invoke(callback, cops, *args); end
   def reset; end
   def trigger_responding_cops(callback, node); end
-  def with_cop_error_handling(cop, node = _); end
+  def with_cop_error_handling(cop, node = T.unsafe(nil)); end
 end
 
 class RuboCop::Cop::Commissioner::InvestigationReport < ::Struct
@@ -858,14 +910,22 @@ class RuboCop::Cop::Commissioner::InvestigationReport < ::Struct
   def processed_source; end
   def processed_source=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RuboCop::Cop::ConditionCorrector
-  def self.correct_negative_condition(node); end
+  class << self
+    def correct_negative_condition(node); end
+
+    private
+
+    def negated_condition(node); end
+  end
 end
 
 module RuboCop::Cop::ConfigurableEnforcedStyle
@@ -894,7 +954,7 @@ module RuboCop::Cop::ConfigurableFormatting
   def check_name(node, name, name_range); end
   def class_emitter_method?(node, name); end
   def report_opposing_styles(node, name); end
-  def valid_name?(node, name, given_style = _); end
+  def valid_name?(node, name, given_style = T.unsafe(nil)); end
 end
 
 module RuboCop::Cop::ConfigurableMax
@@ -920,13 +980,13 @@ end
 RuboCop::Cop::ConfigurableNumbering::FORMATS = T.let(T.unsafe(nil), Hash)
 
 class RuboCop::Cop::Cop < ::RuboCop::Cop::Base
-  def add_offense(node_or_range, location: _, message: _, severity: _, &block); end
+  def add_offense(node_or_range, location: T.unsafe(nil), message: T.unsafe(nil), severity: T.unsafe(nil), &block); end
   def corrections; end
   def find_location(node, loc); end
   def offenses; end
   def on_investigation_end; end
   def on_new_investigation; end
-  def parse(source, path = _); end
+  def parse(source, path = T.unsafe(nil)); end
   def support_autocorrect?; end
 
   private
@@ -939,11 +999,13 @@ class RuboCop::Cop::Cop < ::RuboCop::Cop::Base
   def emulate_v0_callsequence(corrector); end
   def suppress_clobbering; end
 
-  def self.all; end
-  def self.joining_forces; end
-  def self.qualified_cop_name(name, origin); end
-  def self.registry; end
-  def self.support_autocorrect?; end
+  class << self
+    def all; end
+    def joining_forces; end
+    def qualified_cop_name(name, origin); end
+    def registry; end
+    def support_autocorrect?; end
+  end
 end
 
 class RuboCop::Cop::Cop::Correction < ::Struct
@@ -955,10 +1017,12 @@ class RuboCop::Cop::Cop::Correction < ::Struct
   def node; end
   def node=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RuboCop::Cop::Corrector < ::Parser::Source::TreeRewriter
@@ -975,13 +1039,15 @@ class RuboCop::Cop::Corrector < ::Parser::Source::TreeRewriter
   def to_range(node_or_range); end
   def validate_buffer(buffer); end
 
-  def self.source_buffer(source); end
+  class << self
+    def source_buffer(source); end
+  end
 end
 
 module RuboCop::Cop::DefNode
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def non_public_modifier?(node = _); end
+  def non_public_modifier?(node = T.unsafe(nil)); end
 
   private
 
@@ -1039,14 +1105,16 @@ RuboCop::Cop::EachToForCorrector::CORRECTION_WITHOUT_ARGUMENTS = T.let(T.unsafe(
 RuboCop::Cop::EachToForCorrector::CORRECTION_WITH_ARGUMENTS = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::EmptyLineCorrector
-  def self.correct(node); end
-  def self.insert_before(node); end
+  class << self
+    def correct(node); end
+    def insert_before(node); end
+  end
 end
 
 module RuboCop::Cop::EmptyParameter
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def empty_arguments?(node = _); end
+  def empty_arguments?(node = T.unsafe(nil)); end
 
   private
 
@@ -1076,14 +1144,16 @@ module RuboCop::Cop::EnforceSuperclass
   def on_class(node); end
   def on_send(node); end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 module RuboCop::Cop::FirstElementLineBreak
 
   private
 
-  def check_children_line_break(node, children, start = _); end
+  def check_children_line_break(node, children, start = T.unsafe(nil)); end
   def check_method_line_break(node, children); end
   def first_by_line(nodes); end
   def last_by_line(nodes); end
@@ -1122,9 +1192,11 @@ class RuboCop::Cop::Force
   def name; end
   def run_hook(method_name, *args); end
 
-  def self.all; end
-  def self.force_name; end
-  def self.inherited(subclass); end
+  class << self
+    def all; end
+    def force_name; end
+    def inherited(subclass); end
+  end
 end
 
 module RuboCop::Cop::FrozenStringLiteral
@@ -1136,7 +1208,9 @@ module RuboCop::Cop::FrozenStringLiteral
   def frozen_string_literals_enabled?; end
   def leading_comment_lines; end
 
-  def self.frozen_string_literal_comment_exists?; end
+  class << self
+    def frozen_string_literal_comment_exists?; end
+  end
 end
 
 RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL = T.let(T.unsafe(nil), String)
@@ -1196,7 +1270,7 @@ RuboCop::Cop::Gemspec::RequiredRubyVersion::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage < ::RuboCop::Cop::Cop
   def gem_specification?(node0); end
   def on_const(node); end
-  def ruby_version?(node = _); end
+  def ruby_version?(node = T.unsafe(nil)); end
 
   private
 
@@ -1206,10 +1280,10 @@ end
 RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Generator
-  def initialize(name, github_user, output: _); end
+  def initialize(name, github_user, output: T.unsafe(nil)); end
 
-  def inject_config(config_file_path: _, version_added: _); end
-  def inject_require(root_file_path: _); end
+  def inject_config(config_file_path: T.unsafe(nil), version_added: T.unsafe(nil)); end
+  def inject_require(root_file_path: T.unsafe(nil)); end
   def todo; end
   def write_source; end
   def write_spec; end
@@ -1251,7 +1325,7 @@ end
 RuboCop::Cop::Generator::ConfigurationInjector::TEMPLATE = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Generator::RequireFileInjector
-  def initialize(source_path:, root_file_path:, output: _); end
+  def initialize(source_path:, root_file_path:, output: T.unsafe(nil)); end
 
   def inject; end
 
@@ -1358,13 +1432,15 @@ class RuboCop::Cop::HashTransformMethod::Autocorrection < ::Struct
   def trailing; end
   def trailing=(_); end
 
-  def self.[](*_); end
-  def self.from_each_with_object(node, match); end
-  def self.from_hash_brackets_map(node, match); end
-  def self.from_map_to_h(node, match); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def from_each_with_object(node, match); end
+    def from_hash_brackets_map(node, match); end
+    def from_map_to_h(node, match); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RuboCop::Cop::HashTransformMethod::Captures < ::Struct
@@ -1377,10 +1453,12 @@ class RuboCop::Cop::HashTransformMethod::Captures < ::Struct
   def unchanged_body_expr; end
   def unchanged_body_expr=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 module RuboCop::Cop::Heredoc
@@ -1546,7 +1624,7 @@ class RuboCop::Cop::Layout::BlockAlignment < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def block_end_align_target?(node = _, param1); end
+  def block_end_align_target?(node = T.unsafe(nil), param1); end
   def on_block(node); end
   def style_parameter_name; end
 
@@ -1765,7 +1843,7 @@ class RuboCop::Cop::Layout::ElseAlignment < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_case(node); end
   def on_case_match(node); end
-  def on_if(node, base = _); end
+  def on_if(node, base = T.unsafe(nil)); end
   def on_rescue(node); end
 
   private
@@ -1859,7 +1937,9 @@ class RuboCop::Cop::Layout::EmptyLineBetweenDefs < ::RuboCop::Cop::Cop
   def multiple_blank_lines_groups?(first_def_node, second_def_node); end
   def prev_node(node); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Layout::EmptyLineBetweenDefs::MSG = T.let(T.unsafe(nil), String)
@@ -1885,7 +1965,7 @@ class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   include(::RuboCop::Cop::RangeHelp)
 
-  def initialize(config = _, options = _); end
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
 
   def autocorrect(node); end
   def on_block(node); end
@@ -1988,12 +2068,12 @@ module RuboCop::Cop::Layout::EmptyLinesAroundBody
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def constant_definition?(node = _); end
-  def empty_line_required?(node = _); end
+  def constant_definition?(node = T.unsafe(nil)); end
+  def empty_line_required?(node = T.unsafe(nil)); end
 
   private
 
-  def check(node, body, adjusted_first_line: _); end
+  def check(node, body, adjusted_first_line: T.unsafe(nil)); end
   def check_beginning(style, first_line); end
   def check_both(style, first_line, last_line); end
   def check_deferred_empty_line(body); end
@@ -2006,7 +2086,7 @@ module RuboCop::Cop::Layout::EmptyLinesAroundBody
   def first_child_requires_empty_line?(body); end
   def first_empty_line_required_child(body); end
   def message(type, desc); end
-  def namespace?(body, with_one_child: _); end
+  def namespace?(body, with_one_child: T.unsafe(nil)); end
   def previous_line_ignoring_comments(send_line); end
   def valid_body_style?(body); end
 end
@@ -2147,7 +2227,9 @@ class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Cop
   def ignored_range?(ast, start_pos); end
   def ignored_ranges(ast); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String)
@@ -2160,7 +2242,7 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def eligible_method_call?(node = _); end
+  def eligible_method_call?(node = T.unsafe(nil)); end
   def on_csend(node); end
   def on_send(node); end
 
@@ -2350,7 +2432,9 @@ class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop::
   def single_line_send_with_heredoc_receiver?(node); end
   def space?(pos); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::MSG = T.let(T.unsafe(nil), String)
@@ -2433,7 +2517,7 @@ class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::CheckAssignment)
   include(::RuboCop::Cop::IgnoredPattern)
 
-  def access_modifier?(node = _); end
+  def access_modifier?(node = T.unsafe(nil)); end
   def autocorrect(node); end
   def on_block(node); end
   def on_case(case_node); end
@@ -2443,22 +2527,22 @@ class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Cop
   def on_defs(node); end
   def on_ensure(node); end
   def on_for(node); end
-  def on_if(node, base = _); end
+  def on_if(node, base = T.unsafe(nil)); end
   def on_kwbegin(node); end
   def on_module(node); end
   def on_resbody(node); end
   def on_rescue(node); end
   def on_sclass(node); end
   def on_send(node); end
-  def on_until(node, base = _); end
-  def on_while(node, base = _); end
+  def on_until(node, base = T.unsafe(nil)); end
+  def on_while(node, base = T.unsafe(nil)); end
 
   private
 
   def access_modifier_indentation_style; end
   def check_assignment(node, rhs); end
   def check_if(node, body, else_clause, base_loc); end
-  def check_indentation(base_loc, body_node, style = _); end
+  def check_indentation(base_loc, body_node, style = T.unsafe(nil)); end
   def check_members(base, members); end
   def check_members_for_indented_internal_methods_style(members); end
   def check_members_for_normal_style(base, members); end
@@ -2877,7 +2961,7 @@ class RuboCop::Cop::Layout::SpaceAroundBlockParameters < ::RuboCop::Cop::Base
   def check_no_space(space_begin_pos, space_end_pos, msg); end
   def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe); end
   def check_opening_pipe_space(args, opening_pipe); end
-  def check_space(space_begin_pos, space_end_pos, range, msg, node = _); end
+  def check_space(space_begin_pos, space_end_pos, range, msg, node = T.unsafe(nil)); end
   def check_space_style_inside_pipes(args, opening_pipe, closing_pipe); end
   def last_end_pos_inside_pipes(range); end
   def pipes(arguments); end
@@ -2936,7 +3020,7 @@ class RuboCop::Cop::Layout::SpaceAroundKeyword < ::RuboCop::Cop::Cop
   def accept_left_square_bracket?(range); end
   def accept_namespace_operator?(range); end
   def accepted_opening_delimiter?(range, char); end
-  def check(node, locations, begin_keyword = _); end
+  def check(node, locations, begin_keyword = T.unsafe(nil)); end
   def check_begin(node, range, begin_keyword); end
   def check_end(node, range, begin_keyword); end
   def check_keyword(node, range); end
@@ -3027,7 +3111,9 @@ class RuboCop::Cop::Layout::SpaceAroundOperators < ::RuboCop::Cop::Cop
   def should_not_have_surrounding_space?(operator); end
   def space_around_exponent_operator?; end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Layout::SpaceAroundOperators::EXCESSIVE_SPACE = T.let(T.unsafe(nil), String)
@@ -3052,7 +3138,9 @@ class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < ::RuboCop::Cop::Cop
   def space_missing(left_brace); end
   def style_for_empty_braces; end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Layout::SpaceBeforeBlockBraces::DETECTED_MSG = T.let(T.unsafe(nil), String)
@@ -3131,7 +3219,7 @@ class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Co
   def array_brackets(node); end
   def compact(corrector, bracket, side); end
   def compact_corrections(corrector, node, left, right); end
-  def compact_offense(node, token, side: _); end
+  def compact_offense(node, token, side: T.unsafe(nil)); end
   def compact_offenses(node, left, right, start_ok, end_ok); end
   def empty_config; end
   def end_has_own_line?(token); end
@@ -3139,11 +3227,11 @@ class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Co
   def issue_offenses(node, left, right, start_ok, end_ok); end
   def left_array_bracket(node); end
   def line_and_column_for(token); end
-  def multi_dimensional_array?(node, token, side: _); end
-  def next_to_bracket?(token, side: _); end
+  def multi_dimensional_array?(node, token, side: T.unsafe(nil)); end
+  def next_to_bracket?(token, side: T.unsafe(nil)); end
   def next_to_comment?(node, token); end
   def next_to_newline?(node, token); end
-  def qualifies_for_compact?(node, token, side: _); end
+  def qualifies_for_compact?(node, token, side: T.unsafe(nil)); end
   def right_array_bracket(node); end
 end
 
@@ -3371,10 +3459,17 @@ class RuboCop::Cop::LineBreakCorrector
   extend(::RuboCop::PathUtil)
   extend(::RuboCop::Cop::Util)
 
-  def self.break_line_before(range:, node:, corrector:, configured_width:, indent_steps: _); end
-  def self.correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end
-  def self.move_comment(eol_comment:, node:, corrector:); end
-  def self.processed_source; end
+  class << self
+    def break_line_before(range:, node:, corrector:, configured_width:, indent_steps: T.unsafe(nil)); end
+    def correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end
+    def move_comment(eol_comment:, node:, corrector:); end
+    def processed_source; end
+
+    private
+
+    def remove_semicolon(node, corrector); end
+    def semicolon(node); end
+  end
 end
 
 module RuboCop::Cop::LineLengthHelp
@@ -3468,7 +3563,7 @@ RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = T.
 
 class RuboCop::Cop::Lint::BigDecimalNew < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def big_decimal_new(node = _); end
+  def big_decimal_new(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -3476,7 +3571,7 @@ RuboCop::Cop::Lint::BigDecimalNew::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::BooleanSymbol < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def boolean_symbol?(node = _); end
+  def boolean_symbol?(node = T.unsafe(nil)); end
   def on_sym(node); end
 end
 
@@ -3495,7 +3590,7 @@ RuboCop::Cop::Lint::CircularArgumentReference::MSG = T.let(T.unsafe(nil), String
 
 class RuboCop::Cop::Lint::ConstantResolution < ::RuboCop::Cop::Cop
   def on_const(node); end
-  def unqualified_const?(node = _); end
+  def unqualified_const?(node = T.unsafe(nil)); end
 
   private
 
@@ -3507,9 +3602,9 @@ end
 RuboCop::Cop::Lint::ConstantResolution::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::Debugger < ::RuboCop::Cop::Cop
-  def binding_irb_call?(node = _); end
-  def debugger_call?(node = _); end
-  def kernel?(node = _); end
+  def binding_irb_call?(node = T.unsafe(nil)); end
+  def debugger_call?(node = T.unsafe(nil)); end
+  def kernel?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -3537,7 +3632,7 @@ RuboCop::Cop::Lint::DeprecatedClassMethods::DEPRECATED_METHODS_OBJECT = T.let(T.
 class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod
   include(::RuboCop::AST::Sexp)
 
-  def initialize(deprecated:, replacement:, class_constant: _); end
+  def initialize(deprecated:, replacement:, class_constant: T.unsafe(nil)); end
 
   def class_constant; end
   def class_nodes; end
@@ -3550,7 +3645,7 @@ RuboCop::Cop::Lint::DeprecatedClassMethods::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
-  def algorithm_const(node = _); end
+  def algorithm_const(node = T.unsafe(nil)); end
   def autocorrect(node); end
   def on_send(node); end
 
@@ -3607,21 +3702,21 @@ end
 RuboCop::Cop::Lint::DuplicateHashKey::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::DuplicateMethods < ::RuboCop::Cop::Cop
-  def initialize(config = _, options = _); end
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
 
-  def alias_method?(node = _); end
-  def method_alias?(node = _); end
+  def alias_method?(node = T.unsafe(nil)); end
+  def method_alias?(node = T.unsafe(nil)); end
   def on_alias(node); end
   def on_def(node); end
   def on_defs(node); end
   def on_send(node); end
-  def sym_name(node = _); end
+  def sym_name(node = T.unsafe(nil)); end
 
   private
 
   def check_const_receiver(node, name, const_name); end
   def check_self_receiver(node, name); end
-  def found_attr(node, args, readable: _, writable: _); end
+  def found_attr(node, args, readable: T.unsafe(nil), writable: T.unsafe(nil)); end
   def found_instance_method(node, name); end
   def found_method(node, method_name); end
   def lookup_constant(node, const_name); end
@@ -3635,7 +3730,7 @@ end
 RuboCop::Cop::Lint::DuplicateMethods::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::EachWithObjectArgument < ::RuboCop::Cop::Cop
-  def each_with_object?(node = _); end
+  def each_with_object?(node = T.unsafe(nil)); end
   def on_csend(node); end
   def on_send(node); end
 end
@@ -3699,7 +3794,7 @@ class RuboCop::Cop::Lint::ErbNewArguments < ::RuboCop::Cop::Cop
   extend(::RuboCop::Cop::TargetRubyVersion)
 
   def autocorrect(node); end
-  def erb_new_with_non_keyword_arguments(node = _); end
+  def erb_new_with_non_keyword_arguments(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -3726,7 +3821,7 @@ end
 RuboCop::Cop::Lint::FloatOutOfRange::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::FormatParameterMismatch < ::RuboCop::Cop::Cop
-  def called_on_string?(node = _); end
+  def called_on_string?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -3817,7 +3912,7 @@ class RuboCop::Cop::Lint::IneffectiveAccessModifier < ::RuboCop::Cop::Cop
   def check_node(node); end
   def correct_visibility?(node, modifier, ignored_methods); end
   def format_message(modifier); end
-  def ineffective_modifier(node, ignored_methods, modifier = _, &block); end
+  def ineffective_modifier(node, ignored_methods, modifier = T.unsafe(nil), &block); end
   def private_class_method_names(node); end
 end
 
@@ -3831,7 +3926,7 @@ class RuboCop::Cop::Lint::InheritException < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
   def autocorrect(node); end
-  def class_new_call?(node = _); end
+  def class_new_call?(node = T.unsafe(nil)); end
   def on_class(node); end
   def on_send(node); end
 
@@ -3943,16 +4038,16 @@ RuboCop::Cop::Lint::MixedRegexpCaptureTypes::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::MultipleComparison < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def multiple_compare?(node = _); end
+  def multiple_compare?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
 RuboCop::Cop::Lint::MultipleComparison::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::NestedMethodDefinition < ::RuboCop::Cop::Cop
-  def class_or_module_or_struct_new_call?(node = _); end
-  def eval_call?(node = _); end
-  def exec_call?(node = _); end
+  def class_or_module_or_struct_new_call?(node = T.unsafe(nil)); end
+  def eval_call?(node = T.unsafe(nil)); end
+  def exec_call?(node = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
 
@@ -3983,7 +4078,7 @@ RuboCop::Cop::Lint::NestedPercentLiteral::REGEXES = T.let(T.unsafe(nil), Array)
 
 class RuboCop::Cop::Lint::NextWithoutAccumulator < ::RuboCop::Cop::Cop
   def on_block(node); end
-  def on_body_of_reduce(node = _); end
+  def on_body_of_reduce(node = T.unsafe(nil)); end
 
   private
 
@@ -3994,14 +4089,14 @@ RuboCop::Cop::Lint::NextWithoutAccumulator::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::NonDeterministicRequireOrder < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def loop_variable(node = _); end
-  def method_require?(node = _); end
+  def loop_variable(node = T.unsafe(nil)); end
+  def method_require?(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_block_pass(node); end
-  def unsorted_dir_block?(node = _); end
-  def unsorted_dir_each?(node = _); end
-  def unsorted_dir_each_pass?(node = _); end
-  def unsorted_dir_glob_pass?(node = _); end
+  def unsorted_dir_block?(node = T.unsafe(nil)); end
+  def unsorted_dir_each?(node = T.unsafe(nil)); end
+  def unsorted_dir_each_pass?(node = T.unsafe(nil)); end
+  def unsorted_dir_glob_pass?(node = T.unsafe(nil)); end
   def var_is_required?(node0, param1); end
 
   private
@@ -4015,8 +4110,8 @@ end
 RuboCop::Cop::Lint::NonDeterministicRequireOrder::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::NonLocalExitFromIterator < ::RuboCop::Cop::Cop
-  def chained_send?(node = _); end
-  def define_method?(node = _); end
+  def chained_send?(node = T.unsafe(nil)); end
+  def define_method?(node = T.unsafe(nil)); end
   def on_return(return_node); end
 
   private
@@ -4029,9 +4124,9 @@ RuboCop::Cop::Lint::NonLocalExitFromIterator::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::NumberConversion < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def datetime?(node = _); end
+  def datetime?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def to_method(node = _); end
+  def to_method(node = T.unsafe(nil)); end
 
   private
 
@@ -4115,8 +4210,8 @@ RuboCop::Cop::Lint::PercentSymbolArray::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::RaiseException < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def exception?(node = _); end
-  def exception_new_with_message?(node = _); end
+  def exception?(node = T.unsafe(nil)); end
+  def exception_new_with_message?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -4130,7 +4225,7 @@ RuboCop::Cop::Lint::RaiseException::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::RandOne < ::RuboCop::Cop::Cop
   def on_send(node); end
-  def rand_one?(node = _); end
+  def rand_one?(node = T.unsafe(nil)); end
 
   private
 
@@ -4143,7 +4238,7 @@ class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Base
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def initialize(config = _, options = _, offenses = _); end
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil), offenses = T.unsafe(nil)); end
 
   def offenses_to_check; end
   def offenses_to_check=(_); end
@@ -4197,15 +4292,15 @@ class RuboCop::Cop::Lint::RedundantRequireStatement < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def unnecessary_require_statement?(node = _); end
+  def unnecessary_require_statement?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::RedundantRequireStatement::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::RedundantSplatExpansion < ::RuboCop::Cop::Cop
-  def array_new?(node = _); end
+  def array_new?(node = T.unsafe(nil)); end
   def autocorrect(node); end
-  def literal_expansion(node = _); end
+  def literal_expansion(node = T.unsafe(nil)); end
   def on_splat(node); end
 
   private
@@ -4239,7 +4334,7 @@ class RuboCop::Cop::Lint::RedundantStringCoercion < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_interpolation(begin_node); end
-  def to_s_without_args?(node = _); end
+  def to_s_without_args?(node = T.unsafe(nil)); end
 
   private
 
@@ -4255,7 +4350,7 @@ class RuboCop::Cop::Lint::RedundantWithIndex < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_block(node); end
-  def redundant_with_index?(node = _); end
+  def redundant_with_index?(node = T.unsafe(nil)); end
 
   private
 
@@ -4272,7 +4367,7 @@ class RuboCop::Cop::Lint::RedundantWithObject < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_block(node); end
-  def redundant_with_object?(node = _); end
+  def redundant_with_object?(node = T.unsafe(nil)); end
 
   private
 
@@ -4346,7 +4441,7 @@ class RuboCop::Cop::Lint::SafeNavigationChain < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::AllowedMethods)
   include(::RuboCop::Cop::NilMethods)
 
-  def bad_method?(node = _); end
+  def bad_method?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -4375,7 +4470,7 @@ RuboCop::Cop::Lint::SafeNavigationConsistency::MSG = T.let(T.unsafe(nil), String
 class RuboCop::Cop::Lint::SafeNavigationWithEmpty < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_if(node); end
-  def safe_navigation_empty_in_conditional?(node = _); end
+  def safe_navigation_empty_in_conditional?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::SafeNavigationWithEmpty::MSG = T.let(T.unsafe(nil), String)
@@ -4399,7 +4494,7 @@ class RuboCop::Cop::Lint::SendWithMixinArgument < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def send_with_mixin_argument?(node = _); end
+  def send_with_mixin_argument?(node = T.unsafe(nil)); end
 
   private
 
@@ -4461,7 +4556,7 @@ RuboCop::Cop::Lint::ShadowingOuterLocalVariable::MSG = T.let(T.unsafe(nil), Stri
 
 class RuboCop::Cop::Lint::StructNewOverride < ::RuboCop::Cop::Cop
   def on_send(node); end
-  def struct_new(node = _); end
+  def struct_new(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::StructNewOverride::MSG = T.let(T.unsafe(nil), String)
@@ -4511,14 +4606,14 @@ RuboCop::Cop::Lint::UnderscorePrefixedVariableName::MSG = T.let(T.unsafe(nil), S
 
 class RuboCop::Cop::Lint::UnifiedInteger < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def fixnum_or_bignum_const(node = _); end
+  def fixnum_or_bignum_const(node = T.unsafe(nil)); end
   def on_const(node); end
 end
 
 RuboCop::Cop::Lint::UnifiedInteger::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::UnreachableCode < ::RuboCop::Cop::Cop
-  def flow_command?(node = _); end
+  def flow_command?(node = T.unsafe(nil)); end
   def on_begin(node); end
   def on_kwbegin(node); end
 
@@ -4568,7 +4663,7 @@ class RuboCop::Cop::Lint::UnusedMethodArgument < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::Lint::UnusedArgument)
 
   def autocorrect(node); end
-  def not_implemented?(node = _); end
+  def not_implemented?(node = T.unsafe(nil)); end
 
   private
 
@@ -4579,7 +4674,7 @@ end
 
 class RuboCop::Cop::Lint::UriEscapeUnescape < ::RuboCop::Cop::Cop
   def on_send(node); end
-  def uri_escape_unescape?(node = _); end
+  def uri_escape_unescape?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_ESCAPE = T.let(T.unsafe(nil), Array)
@@ -4591,12 +4686,12 @@ RuboCop::Cop::Lint::UriEscapeUnescape::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Lint::UriRegexp < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def uri_regexp_with_argument?(node = _); end
-  def uri_regexp_without_argument?(node = _); end
+  def uri_regexp_with_argument?(node = T.unsafe(nil)); end
+  def uri_regexp_without_argument?(node = T.unsafe(nil)); end
 
   private
 
-  def register_offense(node, top_level: _, arg: _); end
+  def register_offense(node, top_level: T.unsafe(nil), arg: T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::UriRegexp::MSG = T.let(T.unsafe(nil), String)
@@ -4605,14 +4700,14 @@ class RuboCop::Cop::Lint::UselessAccessModifier < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def class_or_instance_eval?(node = _); end
-  def class_or_module_or_struct_new_call?(node = _); end
-  def dynamic_method_definition?(node = _); end
+  def class_or_instance_eval?(node = T.unsafe(nil)); end
+  def class_or_module_or_struct_new_call?(node = T.unsafe(nil)); end
+  def dynamic_method_definition?(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_class(node); end
   def on_module(node); end
   def on_sclass(node); end
-  def static_method_definition?(node = _); end
+  def static_method_definition?(node = T.unsafe(nil)); end
 
   private
 
@@ -4649,7 +4744,7 @@ RuboCop::Cop::Lint::UselessAssignment::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Lint::UselessComparison < ::RuboCop::Cop::Cop
   def on_send(node); end
-  def useless_comparison?(node = _); end
+  def useless_comparison?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Lint::UselessComparison::MSG = T.let(T.unsafe(nil), String)
@@ -4672,7 +4767,7 @@ RuboCop::Cop::Lint::UselessElseWithoutRescue::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Lint::UselessSetterCall < ::RuboCop::Cop::Cop
   def on_def(node); end
   def on_defs(node); end
-  def setter_call_to_local_variable?(node = _); end
+  def setter_call_to_local_variable?(node = T.unsafe(nil)); end
 
   private
 
@@ -4767,7 +4862,9 @@ class RuboCop::Cop::MessageAnnotator
   def style_guide_base_url; end
   def style_guide_url; end
 
-  def self.style_guide_urls; end
+  class << self
+    def style_guide_urls; end
+  end
 end
 
 module RuboCop::Cop::MethodComplexity
@@ -4775,7 +4872,7 @@ module RuboCop::Cop::MethodComplexity
   include(::RuboCop::Cop::IgnoredMethods)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def define_method?(node = _); end
+  def define_method?(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_def(node); end
   def on_defs(node); end
@@ -4847,7 +4944,7 @@ class RuboCop::Cop::Metrics::ClassLength < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::CodeLength)
   include(::RuboCop::Cop::TooManyLines)
 
-  def class_definition?(node = _); end
+  def class_definition?(node = T.unsafe(nil)); end
   def on_casgn(node); end
   def on_class(node); end
 
@@ -4895,7 +4992,7 @@ class RuboCop::Cop::Metrics::ModuleLength < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::CodeLength)
   include(::RuboCop::Cop::TooManyLines)
 
-  def module_definition?(node = _); end
+  def module_definition?(node = T.unsafe(nil)); end
   def on_casgn(node); end
   def on_module(node); end
 
@@ -4907,7 +5004,7 @@ end
 class RuboCop::Cop::Metrics::ParameterLists < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableMax)
 
-  def argument_to_lambda_or_proc?(node = _); end
+  def argument_to_lambda_or_proc?(node = T.unsafe(nil)); end
   def on_args(node); end
 
   private
@@ -4951,7 +5048,9 @@ class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
   def branch?(node); end
   def condition?(node); end
 
-  def self.calculate(node); end
+  class << self
+    def calculate(node); end
+  end
 end
 
 RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::BRANCH_NODES = T.let(T.unsafe(nil), Array)
@@ -4963,11 +5062,11 @@ class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator
   include(::RuboCop::Cop::Util)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def initialize(node, count_comments: _, foldable_types: _); end
+  def initialize(node, count_comments: T.unsafe(nil), foldable_types: T.unsafe(nil)); end
 
   def calculate; end
-  def class_definition?(node = _); end
-  def module_definition?(node = _); end
+  def class_definition?(node = T.unsafe(nil)); end
+  def module_definition?(node = T.unsafe(nil)); end
 
   private
 
@@ -5128,7 +5227,7 @@ module RuboCop::Cop::MultilineLiteralBraceLayout
   def empty_literal?(node); end
   def ignored_literal?(node); end
   def implicit_literal?(node); end
-  def last_line_heredoc?(node, parent = _); end
+  def last_line_heredoc?(node, parent = T.unsafe(nil)); end
   def new_line_needed_before_closing_brace?(node); end
   def opening_brace_on_same_line?(node); end
 end
@@ -5169,7 +5268,7 @@ RuboCop::Cop::Naming::AsciiIdentifiers::IDENTIFIER_MSG = T.let(T.unsafe(nil), St
 
 class RuboCop::Cop::Naming::BinaryOperatorParameterName < ::RuboCop::Cop::Cop
   def on_def(node); end
-  def op_method_candidate?(node = _); end
+  def op_method_candidate?(node = T.unsafe(nil)); end
 
   private
 
@@ -5196,8 +5295,8 @@ end
 RuboCop::Cop::Naming::ClassAndModuleCamelCase::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Naming::ConstantName < ::RuboCop::Cop::Cop
-  def class_or_struct_return_method?(node = _); end
-  def literal_receiver?(node = _); end
+  def class_or_struct_return_method?(node = T.unsafe(nil)); end
+  def literal_receiver?(node = T.unsafe(nil)); end
   def on_casgn(node); end
 
   private
@@ -5280,7 +5379,7 @@ RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def memoized?(node = _); end
+  def memoized?(node = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
 
@@ -5291,6 +5390,13 @@ class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Cop
   def style_parameter_name; end
   def suggested_var(method_name); end
   def variable_name_candidates(method_name); end
+
+  class << self
+
+    private
+
+    def node_pattern; end
+  end
 end
 
 RuboCop::Cop::Naming::MemoizedInstanceVariableName::MSG = T.let(T.unsafe(nil), String)
@@ -5307,8 +5413,8 @@ class RuboCop::Cop::Naming::MethodName < ::RuboCop::Cop::Base
   def on_def(node); end
   def on_defs(node); end
   def on_send(node); end
-  def str_name(node = _); end
-  def sym_name(node = _); end
+  def str_name(node = T.unsafe(nil)); end
+  def sym_name(node = T.unsafe(nil)); end
 
   private
 
@@ -5329,7 +5435,7 @@ end
 class RuboCop::Cop::Naming::PredicateName < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::AllowedMethods)
 
-  def dynamic_method_define(node = _); end
+  def dynamic_method_define(node = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
   def on_send(node); end
@@ -5402,8 +5508,8 @@ RuboCop::Cop::Naming::VariableNumber::MSG = T.let(T.unsafe(nil), String)
 module RuboCop::Cop::NegativeConditional
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def empty_condition?(node = _); end
-  def single_negative?(node = _); end
+  def empty_condition?(node = T.unsafe(nil)); end
+  def single_negative?(node = T.unsafe(nil)); end
 
   private
 
@@ -5425,7 +5531,7 @@ end
 class RuboCop::Cop::Offense
   include(::Comparable)
 
-  def initialize(severity, location, message, cop_name, status = _, corrector = _); end
+  def initialize(severity, location, message, cop_name, status = T.unsafe(nil), corrector = T.unsafe(nil)); end
 
   def <=>(other); end
   def ==(other); end
@@ -5470,10 +5576,12 @@ class RuboCop::Cop::Offense::PseudoSourceRange < ::Struct
   def source_line; end
   def source_line=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 module RuboCop::Cop::OnNormalIfUnless
@@ -5483,9 +5591,16 @@ end
 class RuboCop::Cop::OrderedGemCorrector
   extend(::RuboCop::Cop::OrderedGemNode)
 
-  def self.comments_as_separators; end
-  def self.correct(processed_source, node, previous_declaration, comments_as_separators); end
-  def self.processed_source; end
+  class << self
+    def comments_as_separators; end
+    def correct(processed_source, node, previous_declaration, comments_as_separators); end
+    def processed_source; end
+
+    private
+
+    def declaration_with_comment(node); end
+    def swap_range(corrector, range1, range2); end
+  end
 end
 
 module RuboCop::Cop::OrderedGemNode
@@ -5510,7 +5625,14 @@ module RuboCop::Cop::Parentheses
 end
 
 class RuboCop::Cop::ParenthesesCorrector
-  def self.correct(node); end
+  class << self
+    def correct(node); end
+
+    private
+
+    def next_char_is_question_mark?(node); end
+    def ternary_condition?(node); end
+  end
 end
 
 module RuboCop::Cop::ParserDiagnostic
@@ -5580,10 +5702,10 @@ module RuboCop::Cop::PrecedingFollowingAlignment
   def aligned_operator?(range, line); end
   def aligned_token?(range, line); end
   def aligned_with_adjacent_line?(range, predicate); end
-  def aligned_with_any_line?(line_ranges, range, indent = _, &predicate); end
+  def aligned_with_any_line?(line_ranges, range, indent = T.unsafe(nil), &predicate); end
   def aligned_with_any_line_range?(line_ranges, range, &predicate); end
   def aligned_with_assignment(token, line_range); end
-  def aligned_with_line?(line_nos, range, indent = _); end
+  def aligned_with_line?(line_nos, range, indent = T.unsafe(nil)); end
   def aligned_with_operator?(range); end
   def aligned_with_preceding_assignment(token); end
   def aligned_with_something?(range); end
@@ -5613,9 +5735,11 @@ end
 RuboCop::Cop::PreferredDelimiters::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array)
 
 class RuboCop::Cop::PunctuationCorrector
-  def self.add_space(token); end
-  def self.remove_space(space_before); end
-  def self.swap_comma(range); end
+  class << self
+    def add_space(token); end
+    def remove_space(space_before); end
+    def swap_comma(range); end
+  end
 end
 
 module RuboCop::Cop::RangeHelp
@@ -5628,10 +5752,10 @@ module RuboCop::Cop::RangeHelp
   def final_pos(src, pos, increment, newlines, whitespace); end
   def move_pos(src, pos, step, condition, regexp); end
   def range_between(start_pos, end_pos); end
-  def range_by_whole_lines(range, include_final_newline: _); end
-  def range_with_surrounding_comma(range, side = _); end
-  def range_with_surrounding_space(range:, side: _, newlines: _, whitespace: _); end
-  def source_range(source_buffer, line_number, column, length = _); end
+  def range_by_whole_lines(range, include_final_newline: T.unsafe(nil)); end
+  def range_with_surrounding_comma(range, side = T.unsafe(nil)); end
+  def range_with_surrounding_space(range:, side: T.unsafe(nil), newlines: T.unsafe(nil), whitespace: T.unsafe(nil)); end
+  def source_range(source_buffer, line_number, column, length = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::RangeHelp::BYTE_ORDER_MARK = T.let(T.unsafe(nil), Integer)
@@ -5639,7 +5763,7 @@ RuboCop::Cop::RangeHelp::BYTE_ORDER_MARK = T.let(T.unsafe(nil), Integer)
 module RuboCop::Cop::RationalLiteral
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def rational_literal?(node = _); end
+  def rational_literal?(node = T.unsafe(nil)); end
 end
 
 module RuboCop::Cop::RegexpLiteralHelp
@@ -5655,7 +5779,7 @@ end
 class RuboCop::Cop::Registry
   include(::Enumerable)
 
-  def initialize(cops = _, options = _); end
+  def initialize(cops = T.unsafe(nil), options = T.unsafe(nil)); end
 
   def ==(other); end
   def contains_cop_matching?(names); end
@@ -5664,7 +5788,7 @@ class RuboCop::Cop::Registry
   def departments; end
   def dismiss(cop); end
   def each(&block); end
-  def enabled(config, only = _, only_safe = _); end
+  def enabled(config, only = T.unsafe(nil), only_safe = T.unsafe(nil)); end
   def enabled?(cop, config, only_safe); end
   def enabled_pending_cop?(cop_cfg, config); end
   def enlist(cop); end
@@ -5673,7 +5797,7 @@ class RuboCop::Cop::Registry
   def names; end
   def options; end
   def print_warning(name, path); end
-  def qualified_cop_name(name, path, shall_warn = _); end
+  def qualified_cop_name(name, path, shall_warn = T.unsafe(nil)); end
   def select(&block); end
   def sort!; end
   def to_h; end
@@ -5690,10 +5814,12 @@ class RuboCop::Cop::Registry
   def resolve_badge(given_badge, real_badge, source_path); end
   def with(cops); end
 
-  def self.all; end
-  def self.global; end
-  def self.qualified_cop_name(name, origin); end
-  def self.with_temporary_global(temp_global = _); end
+  class << self
+    def all; end
+    def global; end
+    def qualified_cop_name(name, origin); end
+    def with_temporary_global(temp_global = T.unsafe(nil)); end
+  end
 end
 
 module RuboCop::Cop::RescueNode
@@ -5707,9 +5833,9 @@ end
 module RuboCop::Cop::SafeAssignment
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def empty_condition?(node = _); end
-  def safe_assignment?(node = _); end
-  def setter_method?(node = _); end
+  def empty_condition?(node = T.unsafe(nil)); end
+  def safe_assignment?(node = T.unsafe(nil)); end
+  def setter_method?(node = T.unsafe(nil)); end
 
   private
 
@@ -5720,7 +5846,7 @@ module RuboCop::Cop::Security
 end
 
 class RuboCop::Cop::Security::Eval < ::RuboCop::Cop::Cop
-  def eval?(node = _); end
+  def eval?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -5728,14 +5854,14 @@ RuboCop::Cop::Security::Eval::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Security::JSONLoad < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def json_load(node = _); end
+  def json_load(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
 RuboCop::Cop::Security::JSONLoad::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Security::MarshalLoad < ::RuboCop::Cop::Cop
-  def marshal_load(node = _); end
+  def marshal_load(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -5743,7 +5869,7 @@ RuboCop::Cop::Security::MarshalLoad::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Security::Open < ::RuboCop::Cop::Cop
   def on_send(node); end
-  def open?(node = _); end
+  def open?(node = T.unsafe(nil)); end
 
   private
 
@@ -5760,7 +5886,7 @@ RuboCop::Cop::Security::Open::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Security::YAMLLoad < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def yaml_load(node = _); end
+  def yaml_load(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Security::YAMLLoad::MSG = T.let(T.unsafe(nil), String)
@@ -5778,7 +5904,9 @@ class RuboCop::Cop::Severity
   def name; end
   def to_s; end
 
-  def self.name_from_code(code); end
+  class << self
+    def name_from_code(code); end
+  end
 end
 
 RuboCop::Cop::Severity::CODE_TABLE = T.let(T.unsafe(nil), Hash)
@@ -5819,10 +5947,12 @@ class RuboCop::Cop::SpaceCorrector
   extend(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::SurroundingSpace)
 
-  def self.add_space(processed_source, corrector, left_token, right_token); end
-  def self.empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end
-  def self.processed_source; end
-  def self.remove_space(processed_source, corrector, left_token, right_token); end
+  class << self
+    def add_space(processed_source, corrector, left_token, right_token); end
+    def empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end
+    def processed_source; end
+    def remove_space(processed_source, corrector, left_token, right_token); end
+  end
 end
 
 module RuboCop::Cop::StatementModifier
@@ -5853,7 +5983,9 @@ class RuboCop::Cop::StringLiteralCorrector
   extend(::RuboCop::PathUtil)
   extend(::RuboCop::Cop::Util)
 
-  def self.correct(node, style); end
+  class << self
+    def correct(node, style); end
+  end
 end
 
 module RuboCop::Cop::StringLiteralsHelp
@@ -5871,7 +6003,7 @@ end
 class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def access_modifier_with_symbol?(node = _); end
+  def access_modifier_with_symbol?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -5922,7 +6054,7 @@ class RuboCop::Cop::Style::Alias < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
   def autocorrect(node); end
-  def identifier(node = _); end
+  def identifier(node = T.unsafe(nil)); end
   def on_alias(node); end
   def on_send(node); end
 
@@ -5987,10 +6119,10 @@ end
 class RuboCop::Cop::Style::ArrayCoercion < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def array_splat?(node = _); end
+  def array_splat?(node = T.unsafe(nil)); end
   def on_array(node); end
   def on_if(node); end
-  def unless_array?(node = _); end
+  def unless_array?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::ArrayCoercion::CHECK_MSG = T.let(T.unsafe(nil), String)
@@ -5999,7 +6131,7 @@ RuboCop::Cop::Style::ArrayCoercion::SPLAT_MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::ArrayJoin < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def join_candidate?(node = _); end
+  def join_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -6024,7 +6156,7 @@ class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def class_eval?(node = _); end
+  def class_eval?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -6148,7 +6280,7 @@ class RuboCop::Cop::Style::BlockDelimiters < ::RuboCop::Cop::Cop
   def semantic_message(node); end
   def special_method?(method_name); end
   def special_method_proper_block_style?(node); end
-  def whitespace_after?(range, length = _); end
+  def whitespace_after?(range, length = T.unsafe(nil)); end
   def whitespace_before?(range); end
 end
 
@@ -6160,12 +6292,20 @@ class RuboCop::Cop::Style::CaseCorrector
   extend(::RuboCop::Cop::Style::ConditionalAssignmentHelper)
   extend(::RuboCop::Cop::Style::ConditionalCorrectorHelper)
 
-  def self.correct(cop, node); end
-  def self.move_assignment_inside_condition(node); end
+  class << self
+    def correct(cop, node); end
+    def move_assignment_inside_condition(node); end
+
+    private
+
+    def extract_branches(case_node); end
+    def extract_tail_branches(node); end
+    def move_branch_inside_condition(corrector, branch, condition, assignment, column); end
+  end
 end
 
 class RuboCop::Cop::Style::CaseEquality < ::RuboCop::Cop::Cop
-  def case_equality?(node = _); end
+  def case_equality?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -6247,7 +6387,7 @@ class RuboCop::Cop::Style::ClassCheck < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
   def autocorrect(node); end
-  def class_check?(node = _); end
+  def class_check?(node = T.unsafe(nil)); end
   def message(node); end
   def on_send(node); end
 end
@@ -6292,10 +6432,12 @@ RuboCop::Cop::Style::CollectionMethods::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::ColonMethodCall < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def java_type_node?(node = _); end
+  def java_type_node?(node = T.unsafe(nil)); end
   def on_send(node); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Style::ColonMethodCall::MSG = T.let(T.unsafe(nil), String)
@@ -6379,9 +6521,9 @@ class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::Style::ConditionalAssignmentHelper)
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def assignment_type?(node = _); end
+  def assignment_type?(node = T.unsafe(nil)); end
   def autocorrect(node); end
-  def candidate_condition?(node = _); end
+  def candidate_condition?(node = T.unsafe(nil)); end
   def on_and_asgn(node); end
   def on_case(node); end
   def on_casgn(node); end
@@ -6452,7 +6594,7 @@ module RuboCop::Cop::Style::ConditionalAssignmentHelper
   private
 
   def assignment_rhs_exist?(node); end
-  def expand_elsif(node, elsif_branches = _); end
+  def expand_elsif(node, elsif_branches = T.unsafe(nil)); end
   def lhs_for_send(node); end
   def setter_method?(method_name); end
 end
@@ -6476,7 +6618,7 @@ end
 
 class RuboCop::Cop::Style::ConstantVisibility < ::RuboCop::Cop::Cop
   def on_casgn(node); end
-  def visibility_declaration_for?(node = _, param1); end
+  def visibility_declaration_for?(node = T.unsafe(nil), param1); end
 
   private
 
@@ -6510,10 +6652,10 @@ RuboCop::Cop::Style::Copyright::AUTOCORRECT_EMPTY_WARNING = T.let(T.unsafe(nil),
 RuboCop::Cop::Style::Copyright::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::DateTime < ::RuboCop::Cop::Cop
-  def date_time?(node = _); end
-  def historic_date?(node = _); end
+  def date_time?(node = T.unsafe(nil)); end
+  def historic_date?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def to_datetime?(node = _); end
+  def to_datetime?(node = T.unsafe(nil)); end
 
   private
 
@@ -6534,7 +6676,7 @@ RuboCop::Cop::Style::DefWithParentheses::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::Dir < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def dir_replacement?(node = _); end
+  def dir_replacement?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -6559,8 +6701,8 @@ class RuboCop::Cop::Style::Documentation < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::Style::AnnotationComment)
   include(::RuboCop::Cop::DocumentationComment)
 
-  def constant_definition?(node = _); end
-  def constant_visibility_declaration?(node = _); end
+  def constant_definition?(node = T.unsafe(nil)); end
+  def constant_visibility_declaration?(node = T.unsafe(nil)); end
   def on_class(node); end
   def on_module(node); end
   def outer_module(node0); end
@@ -6572,8 +6714,8 @@ class RuboCop::Cop::Style::Documentation < ::RuboCop::Cop::Cop
   def constant_declaration?(node); end
   def namespace?(node); end
   def nodoc(node); end
-  def nodoc?(comment, require_all = _); end
-  def nodoc_comment?(node, require_all = _); end
+  def nodoc?(comment, require_all = T.unsafe(nil)); end
+  def nodoc_comment?(node, require_all = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::Documentation::MSG = T.let(T.unsafe(nil), String)
@@ -6583,7 +6725,7 @@ class RuboCop::Cop::Style::DocumentationMethod < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::DocumentationComment)
   include(::RuboCop::Cop::DefNode)
 
-  def module_function_node?(node = _); end
+  def module_function_node?(node = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
 
@@ -6605,7 +6747,7 @@ RuboCop::Cop::Style::DoubleCopDisableDirective::MSG = T.let(T.unsafe(nil), Strin
 class RuboCop::Cop::Style::DoubleNegation < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def double_negative?(node = _); end
+  def double_negative?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -6619,7 +6761,7 @@ RuboCop::Cop::Style::DoubleNegation::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::EachForSimpleLoop < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def offending_each_range(node = _); end
+  def offending_each_range(node = T.unsafe(nil)); end
   def on_block(node); end
 end
 
@@ -6629,7 +6771,7 @@ class RuboCop::Cop::Style::EachWithObject < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def each_with_object_candidate?(node = _); end
+  def each_with_object_candidate?(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -6710,13 +6852,13 @@ class RuboCop::Cop::Style::EmptyLiteral < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::FrozenStringLiteral)
   include(::RuboCop::Cop::RangeHelp)
 
-  def array_node(node = _); end
-  def array_with_block(node = _); end
+  def array_node(node = T.unsafe(nil)); end
+  def array_with_block(node = T.unsafe(nil)); end
   def autocorrect(node); end
-  def hash_node(node = _); end
-  def hash_with_block(node = _); end
+  def hash_node(node = T.unsafe(nil)); end
+  def hash_with_block(node = T.unsafe(nil)); end
   def on_send(node); end
-  def str_node(node = _); end
+  def str_node(node = T.unsafe(nil)); end
 
   private
 
@@ -6786,8 +6928,8 @@ end
 RuboCop::Cop::Style::EndBlock::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::EvalWithLocation < ::RuboCop::Cop::Cop
-  def eval_without_location?(node = _); end
-  def line_with_offset?(node = _, param1, param2); end
+  def eval_without_location?(node = T.unsafe(nil)); end
+  def line_with_offset?(node = T.unsafe(nil), param1, param2); end
   def on_send(node); end
 
   private
@@ -6808,7 +6950,7 @@ RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_LINE = T.let(T.unsafe(nil),
 
 class RuboCop::Cop::Style::EvenOdd < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def even_odd_candidate?(node = _); end
+  def even_odd_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -6822,10 +6964,10 @@ class RuboCop::Cop::Style::ExpandPathArguments < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def file_expand_path(node = _); end
+  def file_expand_path(node = T.unsafe(nil)); end
   def on_send(node); end
-  def pathname_new_parent_expand_path(node = _); end
-  def pathname_parent_expand_path(node = _); end
+  def pathname_new_parent_expand_path(node = T.unsafe(nil)); end
+  def pathname_parent_expand_path(node = T.unsafe(nil)); end
 
   private
 
@@ -6864,11 +7006,11 @@ RuboCop::Cop::Style::ExponentialNotation::MESSAGES = T.let(T.unsafe(nil), Hash)
 class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def any_coerce?(node = _); end
-  def both_coerce?(node = _); end
-  def left_coerce?(node = _); end
+  def any_coerce?(node = T.unsafe(nil)); end
+  def both_coerce?(node = T.unsafe(nil)); end
+  def left_coerce?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def right_coerce?(node = _); end
+  def right_coerce?(node = T.unsafe(nil)); end
 
   private
 
@@ -6901,11 +7043,11 @@ class RuboCop::Cop::Style::FormatString < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
   def autocorrect(node); end
-  def formatter(node = _); end
+  def formatter(node = T.unsafe(nil)); end
   def message(detected_style); end
   def method_name(style_name); end
   def on_send(node); end
-  def variable_argument?(node = _); end
+  def variable_argument?(node = T.unsafe(nil)); end
 
   private
 
@@ -6918,7 +7060,7 @@ RuboCop::Cop::Style::FormatString::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::FormatStringToken < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def format_string_in_typical_context?(node = _); end
+  def format_string_in_typical_context?(node = T.unsafe(nil)); end
   def on_str(node); end
 
   private
@@ -6991,7 +7133,7 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Cop
 
   private
 
-  def accepted_form?(node, ending = _); end
+  def accepted_form?(node, ending = T.unsafe(nil)); end
   def accepted_if?(node, ending); end
   def check_ending_if(node); end
   def guard_clause_source(guard_clause); end
@@ -7019,7 +7161,7 @@ class RuboCop::Cop::Style::HashEachMethods < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::Lint::UnusedArgument)
 
   def autocorrect(node); end
-  def kv_each(node = _); end
+  def kv_each(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -7036,7 +7178,7 @@ end
 RuboCop::Cop::Style::HashEachMethods::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::HashLikeCase < ::RuboCop::Cop::Base
-  def hash_like_case?(node = _); end
+  def hash_like_case?(node = T.unsafe(nil)); end
   def on_case(node); end
 
   private
@@ -7083,9 +7225,9 @@ class RuboCop::Cop::Style::HashTransformKeys < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::HashTransformMethod)
   extend(::RuboCop::Cop::TargetRubyVersion)
 
-  def on_bad_each_with_object(node = _); end
-  def on_bad_hash_brackets_map(node = _); end
-  def on_bad_map_to_h(node = _); end
+  def on_bad_each_with_object(node = T.unsafe(nil)); end
+  def on_bad_hash_brackets_map(node = T.unsafe(nil)); end
+  def on_bad_map_to_h(node = T.unsafe(nil)); end
 
   private
 
@@ -7096,9 +7238,9 @@ end
 class RuboCop::Cop::Style::HashTransformValues < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::HashTransformMethod)
 
-  def on_bad_each_with_object(node = _); end
-  def on_bad_hash_brackets_map(node = _); end
-  def on_bad_map_to_h(node = _); end
+  def on_bad_each_with_object(node = T.unsafe(nil)); end
+  def on_bad_hash_brackets_map(node = T.unsafe(nil)); end
+  def on_bad_map_to_h(node = T.unsafe(nil)); end
 
   private
 
@@ -7126,8 +7268,15 @@ class RuboCop::Cop::Style::IfCorrector
   extend(::RuboCop::Cop::Style::ConditionalAssignmentHelper)
   extend(::RuboCop::Cop::Style::ConditionalCorrectorHelper)
 
-  def self.correct(cop, node); end
-  def self.move_assignment_inside_condition(node); end
+  class << self
+    def correct(cop, node); end
+    def move_assignment_inside_condition(node); end
+
+    private
+
+    def extract_tail_branches(node); end
+    def move_branch_inside_condition(corrector, branch, condition, assignment, column); end
+  end
 end
 
 class RuboCop::Cop::Style::IfInsideElse < ::RuboCop::Cop::Cop
@@ -7196,7 +7345,7 @@ end
 RuboCop::Cop::Style::IfWithSemicolon::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::ImplicitRuntimeError < ::RuboCop::Cop::Cop
-  def implicit_runtime_error_raise_or_fail(node = _); end
+  def implicit_runtime_error_raise_or_fail(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -7241,8 +7390,8 @@ class RuboCop::Cop::Style::InverseMethods < ::RuboCop::Cop::Cop
   def correct_inverse_block(node); end
   def correct_inverse_method(node); end
   def correct_inverse_selector(block, corrector); end
-  def inverse_block?(node = _); end
-  def inverse_candidate?(node = _); end
+  def inverse_block?(node = T.unsafe(nil)); end
+  def inverse_candidate?(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_send(node); end
 
@@ -7258,7 +7407,9 @@ class RuboCop::Cop::Style::InverseMethods < ::RuboCop::Cop::Cop
   def possible_class_hierarchy_check?(lhs, rhs, method); end
   def remove_end_parenthesis(corrector, node, method, method_call); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Style::InverseMethods::CAMEL_CASE = T.let(T.unsafe(nil), Regexp)
@@ -7344,7 +7495,9 @@ class RuboCop::Cop::Style::LineEndConcatenation < ::RuboCop::Cop::Cop
   def standard_string_literal?(token); end
   def token_after_last_string(successor, base_index); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_BEGIN_TOKEN = T.let(T.unsafe(nil), Symbol)
@@ -7379,7 +7532,7 @@ end
 
 module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
   def autocorrect(node); end
-  def message(_node = _); end
+  def message(_node = T.unsafe(nil)); end
   def on_csend(node); end
   def on_send(node); end
   def on_super(node); end
@@ -7414,7 +7567,7 @@ RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::TRAILING_WH
 
 module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
   def autocorrect(node); end
-  def message(_node = _); end
+  def message(_node = T.unsafe(nil)); end
   def on_csend(node); end
   def on_send(node); end
   def on_super(node); end
@@ -7484,7 +7637,7 @@ RuboCop::Cop::Style::MethodMissingSuper::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::MinMax < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def min_max_candidate(node = _); end
+  def min_max_candidate(node = T.unsafe(nil)); end
   def on_array(node); end
   def on_return(node); end
 
@@ -7561,9 +7714,9 @@ RuboCop::Cop::Style::MixinGrouping::MIXIN_METHODS = T.let(T.unsafe(nil), Array)
 RuboCop::Cop::Style::MixinGrouping::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::MixinUsage < ::RuboCop::Cop::Cop
-  def include_statement(node = _); end
+  def include_statement(node = T.unsafe(nil)); end
   def on_send(node); end
-  def wrapped_macro_scope?(node = _); end
+  def wrapped_macro_scope?(node = T.unsafe(nil)); end
 
   private
 
@@ -7578,10 +7731,10 @@ class RuboCop::Cop::Style::ModuleFunction < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
   def autocorrect(node); end
-  def extend_self_node?(node = _); end
-  def module_function_node?(node = _); end
+  def extend_self_node?(node = T.unsafe(nil)); end
+  def module_function_node?(node = T.unsafe(nil)); end
   def on_module(node); end
-  def private_directive?(node = _); end
+  def private_directive?(node = T.unsafe(nil)); end
 
   private
 
@@ -7692,8 +7845,8 @@ RuboCop::Cop::Style::MultilineWhenThen::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Cop
   def on_or(node); end
-  def simple_comparison?(node = _); end
-  def simple_double_comparison?(node = _); end
+  def simple_comparison?(node = T.unsafe(nil)); end
+  def simple_double_comparison?(node = T.unsafe(nil)); end
 
   private
 
@@ -7715,9 +7868,9 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_casgn(node); end
   def on_or_asgn(node); end
-  def operation_produces_immutable_object?(node = _); end
-  def range_enclosed_in_parentheses?(node = _); end
-  def splat_value(node = _); end
+  def operation_produces_immutable_object?(node = T.unsafe(nil)); end
+  def range_enclosed_in_parentheses?(node = T.unsafe(nil)); end
+  def splat_value(node = T.unsafe(nil)); end
 
   private
 
@@ -7852,7 +8005,9 @@ class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Cop
   def reindentable_lines(node); end
   def simple_if_without_break?(node); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Style::Next::EXIT_TYPES = T.let(T.unsafe(nil), Array)
@@ -7863,8 +8018,8 @@ class RuboCop::Cop::Style::NilComparison < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
   def autocorrect(node); end
-  def nil_check?(node = _); end
-  def nil_comparison?(node = _); end
+  def nil_check?(node = T.unsafe(nil)); end
+  def nil_comparison?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -7880,13 +8035,13 @@ RuboCop::Cop::Style::NilComparison::PREDICATE_MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::NonNilCheck < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def nil_check?(node = _); end
-  def not_and_nil_check?(node = _); end
-  def not_equal_to_nil?(node = _); end
+  def nil_check?(node = T.unsafe(nil)); end
+  def not_and_nil_check?(node = T.unsafe(nil)); end
+  def not_equal_to_nil?(node = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
   def on_send(node); end
-  def unless_check?(node = _); end
+  def unless_check?(node = T.unsafe(nil)); end
 
   private
 
@@ -7984,10 +8139,10 @@ class RuboCop::Cop::Style::NumericPredicate < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::IgnoredMethods)
 
   def autocorrect(node); end
-  def comparison(node = _); end
-  def inverted_comparison(node = _); end
+  def comparison(node = T.unsafe(nil)); end
+  def inverted_comparison(node = T.unsafe(nil)); end
   def on_send(node); end
-  def predicate(node = _); end
+  def predicate(node = T.unsafe(nil)); end
 
   private
 
@@ -8023,7 +8178,7 @@ RuboCop::Cop::Style::OneLineConditional::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::OptionHash < ::RuboCop::Cop::Cop
   def on_args(node); end
-  def option_hash(node = _); end
+  def option_hash(node = T.unsafe(nil)); end
 
   private
 
@@ -8052,8 +8207,8 @@ class RuboCop::Cop::Style::OrAssignment < ::RuboCop::Cop::Cop
   def on_if(node); end
   def on_ivasgn(node); end
   def on_lvasgn(node); end
-  def ternary_assignment?(node = _); end
-  def unless_assignment?(node = _); end
+  def ternary_assignment?(node = T.unsafe(nil)); end
+  def unless_assignment?(node = T.unsafe(nil)); end
 
   private
 
@@ -8067,7 +8222,7 @@ class RuboCop::Cop::Style::ParallelAssignment < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RescueNode)
 
   def autocorrect(node); end
-  def implicit_self_getter?(node = _); end
+  def implicit_self_getter?(node = T.unsafe(nil)); end
   def on_masgn(node); end
 
   private
@@ -8094,7 +8249,7 @@ class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter
   def tsort_each_child(assignment); end
   def tsort_each_node; end
   def uses_var?(node0, param1); end
-  def var_name(node = _); end
+  def var_name(node = T.unsafe(nil)); end
 end
 
 class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
@@ -8144,7 +8299,7 @@ class RuboCop::Cop::Style::ParenthesesAroundCondition < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::Parentheses)
 
   def autocorrect(node); end
-  def control_op_condition(node = _); end
+  def control_op_condition(node = T.unsafe(nil)); end
   def on_if(node); end
   def on_until(node); end
   def on_while(node); end
@@ -8231,7 +8386,7 @@ RuboCop::Cop::Style::PreferredHashMethods::OFFENDING_SELECTORS = T.let(T.unsafe(
 class RuboCop::Cop::Style::Proc < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_block(node); end
-  def proc_new?(node = _); end
+  def proc_new?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::Proc::MSG = T.let(T.unsafe(nil), String)
@@ -8259,12 +8414,12 @@ RuboCop::Cop::Style::RaiseArgs::EXPLODED_MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::RandomWithOffset < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def integer_op_rand?(node = _); end
+  def integer_op_rand?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def rand_modified?(node = _); end
-  def rand_op_integer?(node = _); end
-  def random_call(node = _); end
-  def to_int(node = _); end
+  def rand_modified?(node = T.unsafe(nil)); end
+  def rand_op_integer?(node = T.unsafe(nil)); end
+  def random_call(node = T.unsafe(nil)); end
+  def to_int(node = T.unsafe(nil)); end
 
   private
 
@@ -8281,7 +8436,7 @@ class RuboCop::Cop::Style::RedundantAssignment < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_def(node); end
   def on_defs(node); end
-  def redundant_assignment?(node = _); end
+  def redundant_assignment?(node = T.unsafe(nil)); end
 
   private
 
@@ -8351,8 +8506,8 @@ class RuboCop::Cop::Style::RedundantConditional < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_if(node); end
-  def redundant_condition?(node = _); end
-  def redundant_condition_inverted?(node = _); end
+  def redundant_condition?(node = T.unsafe(nil)); end
+  def redundant_condition_inverted?(node = T.unsafe(nil)); end
 
   private
 
@@ -8371,8 +8526,8 @@ RuboCop::Cop::Style::RedundantConditional::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::RedundantException < ::RuboCop::Cop::Base
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def compact?(node = _); end
-  def exploded?(node = _); end
+  def compact?(node = T.unsafe(nil)); end
+  def exploded?(node = T.unsafe(nil)); end
   def fix_compact(node); end
   def fix_exploded(node); end
   def on_send(node); end
@@ -8388,8 +8543,8 @@ class RuboCop::Cop::Style::RedundantFetchBlock < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_block(node); end
-  def rails_cache?(node = _); end
-  def redundant_fetch_block_candidate?(node = _); end
+  def rails_cache?(node = T.unsafe(nil)); end
+  def redundant_fetch_block_candidate?(node = T.unsafe(nil)); end
 
   private
 
@@ -8408,7 +8563,7 @@ RuboCop::Cop::Style::RedundantFetchBlock::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::RedundantFileExtensionInRequire < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def require_call?(node = _); end
+  def require_call?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::RedundantFileExtensionInRequire::MSG = T.let(T.unsafe(nil), String)
@@ -8418,7 +8573,7 @@ class RuboCop::Cop::Style::RedundantFreeze < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def operation_produces_immutable_object?(node = _); end
+  def operation_produces_immutable_object?(node = T.unsafe(nil)); end
 
   private
 
@@ -8447,7 +8602,9 @@ class RuboCop::Cop::Style::RedundantInterpolation < ::RuboCop::Cop::Cop
   def single_variable_interpolation?(node); end
   def variable_interpolation?(node); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Style::RedundantInterpolation::MSG = T.let(T.unsafe(nil), String)
@@ -8455,16 +8612,16 @@ RuboCop::Cop::Style::RedundantInterpolation::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::Parentheses)
 
-  def arg_in_call_with_block?(node = _); end
+  def arg_in_call_with_block?(node = T.unsafe(nil)); end
   def autocorrect(node); end
-  def first_send_argument?(node = _); end
-  def first_super_argument?(node = _); end
-  def first_yield_argument?(node = _); end
-  def method_node_and_args(node = _); end
+  def first_send_argument?(node = T.unsafe(nil)); end
+  def first_super_argument?(node = T.unsafe(nil)); end
+  def first_yield_argument?(node = T.unsafe(nil)); end
+  def method_node_and_args(node = T.unsafe(nil)); end
   def on_begin(node); end
-  def range_end?(node = _); end
-  def rescue?(node = _); end
-  def square_brackets?(node = _); end
+  def range_end?(node = T.unsafe(nil)); end
+  def rescue?(node = T.unsafe(nil)); end
+  def square_brackets?(node = T.unsafe(nil)); end
 
   private
 
@@ -8602,7 +8759,7 @@ RuboCop::Cop::Style::RedundantReturn::MSG = T.let(T.unsafe(nil), String)
 RuboCop::Cop::Style::RedundantReturn::MULTI_RETURN_MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Style::RedundantSelf < ::RuboCop::Cop::Cop
-  def initialize(config = _, options = _); end
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
 
   def autocorrect(node); end
   def on_and_asgn(node); end
@@ -8620,13 +8777,15 @@ class RuboCop::Cop::Style::RedundantSelf < ::RuboCop::Cop::Cop
   private
 
   def add_lhs_to_local_variables_scopes(rhs, lhs); end
-  def add_scope(node, local_variables = _); end
+  def add_scope(node, local_variables = T.unsafe(nil)); end
   def allow_self(node); end
   def allowed_send_node?(node); end
   def on_argument(node); end
   def regular_method_call?(node); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Style::RedundantSelf::KERNEL_METHODS = T.let(T.unsafe(nil), Array)
@@ -8640,7 +8799,7 @@ class RuboCop::Cop::Style::RedundantSort < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def redundant_sort?(node = _); end
+  def redundant_sort?(node = T.unsafe(nil)); end
 
   private
 
@@ -8660,7 +8819,7 @@ class RuboCop::Cop::Style::RedundantSortBy < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_block(node); end
-  def redundant_sort_by(node = _); end
+  def redundant_sort_by(node = T.unsafe(nil)); end
 
   private
 
@@ -8694,7 +8853,7 @@ class RuboCop::Cop::Style::RegexpLiteral < ::RuboCop::Cop::Cop
   def inner_slash_before_correction(node); end
   def inner_slash_for(opening_delimiter); end
   def inner_slash_indices(node); end
-  def node_body(node, include_begin_nodes: _); end
+  def node_body(node, include_begin_nodes: T.unsafe(nil)); end
   def preferred_delimiters; end
   def slash_literal?(node); end
 end
@@ -8720,8 +8879,8 @@ class RuboCop::Cop::Style::RescueStandardError < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_resbody(node); end
-  def rescue_standard_error?(node = _); end
-  def rescue_without_error_class?(node = _); end
+  def rescue_standard_error?(node = T.unsafe(nil)); end
+  def rescue_without_error_class?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::RescueStandardError::MSG_EXPLICIT = T.let(T.unsafe(nil), String)
@@ -8732,11 +8891,11 @@ class RuboCop::Cop::Style::ReturnNil < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
   def autocorrect(node); end
-  def chained_send?(node = _); end
-  def define_method?(node = _); end
+  def chained_send?(node = T.unsafe(nil)); end
+  def define_method?(node = T.unsafe(nil)); end
   def on_return(node); end
-  def return_nil_node?(node = _); end
-  def return_node?(node = _); end
+  def return_nil_node?(node = T.unsafe(nil)); end
+  def return_node?(node = T.unsafe(nil)); end
 
   private
 
@@ -8756,8 +8915,8 @@ class RuboCop::Cop::Style::SafeNavigation < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def check_node(node); end
-  def modifier_if_safe_navigation_candidate(node = _); end
-  def not_nil_check?(node = _); end
+  def modifier_if_safe_navigation_candidate(node = T.unsafe(nil)); end
+  def not_nil_check?(node = T.unsafe(nil)); end
   def on_and(node); end
   def on_if(node); end
   def use_var_only_in_unless_modifier?(node, variable); end
@@ -8790,7 +8949,7 @@ RuboCop::Cop::Style::SafeNavigation::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::Sample < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def sample_candidate?(node = _); end
+  def sample_candidate?(node = T.unsafe(nil)); end
 
   private
 
@@ -8823,7 +8982,9 @@ class RuboCop::Cop::Style::SelfAssignment < ::RuboCop::Cop::Cop
   def check_boolean_node(node, rhs, var_name, var_type); end
   def check_send_node(node, rhs, var_name, var_type); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Style::SelfAssignment::MSG = T.let(T.unsafe(nil), String)
@@ -8850,7 +9011,7 @@ RuboCop::Cop::Style::Semicolon::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::Send < ::RuboCop::Cop::Cop
   def on_csend(node); end
   def on_send(node); end
-  def sending?(node = _); end
+  def sending?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::Send::MSG = T.let(T.unsafe(nil), String)
@@ -8861,7 +9022,7 @@ class RuboCop::Cop::Style::SignalException < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def custom_fail_methods(node0); end
   def investigate(processed_source); end
-  def kernel_call?(node = _, param1); end
+  def kernel_call?(node = T.unsafe(nil), param1); end
   def on_rescue(node); end
   def on_send(node); end
 
@@ -8917,7 +9078,7 @@ class RuboCop::Cop::Style::SlicingWithRange < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def range_till_minus_one?(node = _); end
+  def range_till_minus_one?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::SlicingWithRange::MSG = T.let(T.unsafe(nil), String)
@@ -8977,7 +9138,7 @@ class RuboCop::Cop::Style::StderrPuts < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def stderr_puts?(node = _); end
+  def stderr_puts?(node = T.unsafe(nil)); end
 
   private
 
@@ -8991,8 +9152,8 @@ RuboCop::Cop::Style::StderrPuts::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::StringHashKeys < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_pair(node); end
-  def receive_environments_method?(node = _); end
-  def string_hash_key?(node = _); end
+  def receive_environments_method?(node = T.unsafe(nil)); end
+  def string_hash_key?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Style::StringHashKeys::MSG = T.let(T.unsafe(nil), String)
@@ -9051,7 +9212,7 @@ class RuboCop::Cop::Style::Strip < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def lstrip_rstrip(node = _); end
+  def lstrip_rstrip(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -9062,7 +9223,7 @@ class RuboCop::Cop::Style::StructInheritance < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_class(node); end
-  def struct_constructor?(node = _); end
+  def struct_constructor?(node = T.unsafe(nil)); end
 
   private
 
@@ -9087,8 +9248,10 @@ class RuboCop::Cop::Style::SymbolArray < ::RuboCop::Cop::Cop
   def symbols_contain_spaces?(node); end
   def to_symbol_literal(string); end
 
-  def self.largest_brackets; end
-  def self.largest_brackets=(_); end
+  class << self
+    def largest_brackets; end
+    def largest_brackets=(_); end
+  end
 end
 
 RuboCop::Cop::Style::SymbolArray::ARRAY_MSG = T.let(T.unsafe(nil), String)
@@ -9109,8 +9272,8 @@ class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def destructuring_block_argument?(argument_node); end
   def on_block(node); end
-  def proc_node?(node = _); end
-  def symbol_proc?(node = _); end
+  def proc_node?(node = T.unsafe(nil)); end
+  def symbol_proc?(node = T.unsafe(nil)); end
 
   private
 
@@ -9120,7 +9283,9 @@ class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Cop
   def block_range_with_space(node); end
   def register_offense(node, method_name, block_method_name); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Style::SymbolProc::MSG = T.let(T.unsafe(nil), String)
@@ -9131,8 +9296,19 @@ class RuboCop::Cop::Style::TernaryCorrector
   extend(::RuboCop::Cop::Style::ConditionalAssignmentHelper)
   extend(::RuboCop::Cop::Style::ConditionalCorrectorHelper)
 
-  def self.correct(node); end
-  def self.move_assignment_inside_condition(node); end
+  class << self
+    def correct(node); end
+    def move_assignment_inside_condition(node); end
+
+    private
+
+    def correction(node); end
+    def element_assignment?(node); end
+    def extract_branches(node); end
+    def move_branch_inside_condition(corrector, branch, assignment); end
+    def remove_parentheses(corrector, node); end
+    def ternary(node); end
+  end
 end
 
 class RuboCop::Cop::Style::TernaryParentheses < ::RuboCop::Cop::Cop
@@ -9142,7 +9318,7 @@ class RuboCop::Cop::Style::TernaryParentheses < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::SurroundingSpace)
 
   def autocorrect(node); end
-  def method_name(node = _); end
+  def method_name(node = T.unsafe(nil)); end
   def on_if(node); end
   def only_closing_parenthesis_is_last_line?(condition); end
 
@@ -9214,7 +9390,9 @@ class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Cop
   def on_csend(node); end
   def on_send(node); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 class RuboCop::Cop::Style::TrailingCommaInArrayLiteral < ::RuboCop::Cop::Cop
@@ -9293,7 +9471,7 @@ class RuboCop::Cop::Style::TrivialAccessors < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::AllowedMethods)
 
   def autocorrect(node); end
-  def looks_like_trivial_writer?(node = _); end
+  def looks_like_trivial_writer?(node = T.unsafe(nil)); end
   def on_def(node); end
   def on_defs(node); end
 
@@ -9337,7 +9515,7 @@ RuboCop::Cop::Style::UnlessElse::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Style::UnpackFirst < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def unpack_and_first_element?(node = _); end
+  def unpack_and_first_element?(node = T.unsafe(nil)); end
 
   private
 
@@ -9407,8 +9585,10 @@ class RuboCop::Cop::Style::WordArray < ::RuboCop::Cop::Cop
   def correct_bracketed(node); end
   def word_regex; end
 
-  def self.largest_brackets; end
-  def self.largest_brackets=(_); end
+  class << self
+    def largest_brackets; end
+    def largest_brackets=(_); end
+  end
 end
 
 RuboCop::Cop::Style::WordArray::ARRAY_MSG = T.let(T.unsafe(nil), String)
@@ -9420,7 +9600,7 @@ class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def file_constant_equal_program_name?(node = _); end
+  def file_constant_equal_program_name?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -9452,12 +9632,12 @@ RuboCop::Cop::Style::YodaCondition::REVERSE_COMPARISON = T.let(T.unsafe(nil), Ha
 
 class RuboCop::Cop::Style::ZeroLengthPredicate < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def non_polymorphic_collection?(node = _); end
-  def nonzero_length_predicate(node = _); end
+  def non_polymorphic_collection?(node = T.unsafe(nil)); end
+  def nonzero_length_predicate(node = T.unsafe(nil)); end
   def on_send(node); end
-  def other_receiver(node = _); end
-  def zero_length_predicate(node = _); end
-  def zero_length_receiver(node = _); end
+  def other_receiver(node = T.unsafe(nil)); end
+  def zero_length_predicate(node = T.unsafe(nil)); end
+  def zero_length_receiver(node = T.unsafe(nil)); end
 
   private
 
@@ -9483,7 +9663,7 @@ module RuboCop::Cop::SurroundingSpace
   def index_of_first_token(node); end
   def index_of_last_token(node); end
   def no_space_between?(left_bracket_token, right_bracket_token); end
-  def no_space_offenses(node, left_token, right_token, message, start_ok: _, end_ok: _); end
+  def no_space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end
   def offending_empty_no_space?(config, left_token, right_token); end
   def offending_empty_space?(config, left_token, right_token); end
   def on_new_investigation; end
@@ -9491,7 +9671,7 @@ module RuboCop::Cop::SurroundingSpace
   def side_space_range(range:, side:); end
   def space_between?(left_bracket_token, right_bracket_token); end
   def space_offense(node, token, side, message, command); end
-  def space_offenses(node, left_token, right_token, message, start_ok: _, end_ok: _); end
+  def space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end
   def token_table; end
 end
 
@@ -9508,7 +9688,7 @@ module RuboCop::Cop::TargetRubyVersion
 end
 
 class RuboCop::Cop::Team
-  def initialize(cops, config = _, options = _); end
+  def initialize(cops, config = T.unsafe(nil), options = T.unsafe(nil)); end
 
   def autocorrect?; end
   def cops; end
@@ -9540,10 +9720,12 @@ class RuboCop::Cop::Team
   def suppress_clobbering; end
   def validate_config; end
 
-  def self.forces_for(cops); end
-  def self.mobilize(cop_classes, config, options = _); end
-  def self.mobilize_cops(cop_classes, config, options = _); end
-  def self.new(cop_or_classes, config, options = _); end
+  class << self
+    def forces_for(cops); end
+    def mobilize(cop_classes, config, options = T.unsafe(nil)); end
+    def mobilize_cops(cop_classes, config, options = T.unsafe(nil)); end
+    def new(cop_or_classes, config, options = T.unsafe(nil)); end
+  end
 end
 
 module RuboCop::Cop::TooManyLines
@@ -9629,9 +9811,11 @@ RuboCop::Cop::UncommunicativeName::NUM_MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::UnusedArgCorrector
   extend(::RuboCop::Cop::RangeHelp)
 
-  def self.correct(processed_source, node); end
-  def self.correct_for_blockarg_type(node); end
-  def self.processed_source; end
+  class << self
+    def correct(processed_source, node); end
+    def correct_for_blockarg_type(node); end
+    def processed_source; end
+  end
 end
 
 module RuboCop::Cop::Util
@@ -9653,7 +9837,7 @@ module RuboCop::Cop::Util
   def interpret_string_escapes(string); end
   def line_range(node); end
   def needs_escaping?(string); end
-  def on_node(syms, sexp, excludes = _, &block); end
+  def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end
   def parentheses?(node); end
   def same_line?(node1, node2); end
   def to_string_literal(string); end
@@ -9661,25 +9845,27 @@ module RuboCop::Cop::Util
   def tokens(node); end
   def trim_string_interporation_escape_character(str); end
 
-  def self.add_parentheses(node, corrector); end
-  def self.args_begin(node); end
-  def self.args_end(node); end
-  def self.begins_its_line?(range); end
-  def self.comment_line?(line_source); end
-  def self.comment_lines?(node); end
-  def self.double_quotes_required?(string); end
-  def self.escape_string(string); end
-  def self.first_part_of_call_chain(node); end
-  def self.interpret_string_escapes(string); end
-  def self.line_range(node); end
-  def self.needs_escaping?(string); end
-  def self.on_node(syms, sexp, excludes = _, &block); end
-  def self.parentheses?(node); end
-  def self.same_line?(node1, node2); end
-  def self.to_string_literal(string); end
-  def self.to_supported_styles(enforced_style); end
-  def self.tokens(node); end
-  def self.trim_string_interporation_escape_character(str); end
+  class << self
+    def add_parentheses(node, corrector); end
+    def args_begin(node); end
+    def args_end(node); end
+    def begins_its_line?(range); end
+    def comment_line?(line_source); end
+    def comment_lines?(node); end
+    def double_quotes_required?(string); end
+    def escape_string(string); end
+    def first_part_of_call_chain(node); end
+    def interpret_string_escapes(string); end
+    def line_range(node); end
+    def needs_escaping?(string); end
+    def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end
+    def parentheses?(node); end
+    def same_line?(node1, node2); end
+    def to_string_literal(string); end
+    def to_supported_styles(enforced_style); end
+    def tokens(node); end
+    def trim_string_interporation_escape_character(str); end
+  end
 end
 
 RuboCop::Cop::Util::LITERAL_REGEX = T.let(T.unsafe(nil), Regexp)
@@ -9812,14 +9998,18 @@ class RuboCop::Cop::VariableForce::AssignmentReference < ::Struct
   def node; end
   def node=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 module RuboCop::Cop::VariableForce::Branch
-  def self.of(target_node, scope: _); end
+  class << self
+    def of(target_node, scope: T.unsafe(nil)); end
+  end
 end
 
 class RuboCop::Cop::VariableForce::Branch::And < ::RuboCop::Cop::VariableForce::Branch::Base
@@ -9836,7 +10026,7 @@ class RuboCop::Cop::VariableForce::Branch::Base < ::Struct
   def child_node; end
   def child_node=(_); end
   def control_node; end
-  def each_ancestor(include_self: _, &block); end
+  def each_ancestor(include_self: T.unsafe(nil), &block); end
   def eql?(other); end
   def exclusive_with?(other); end
   def hash; end
@@ -9850,14 +10040,16 @@ class RuboCop::Cop::VariableForce::Branch::Base < ::Struct
 
   def scan_ancestors; end
 
-  def self.[](*_); end
-  def self.classes; end
-  def self.define_predicate(name, child_index: _); end
-  def self.inherited(subclass); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
-  def self.type; end
+  class << self
+    def [](*_); end
+    def classes; end
+    def define_predicate(name, child_index: T.unsafe(nil)); end
+    def inherited(subclass); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+    def type; end
+  end
 end
 
 RuboCop::Cop::VariableForce::Branch::CLASSES_BY_TYPE = T.let(T.unsafe(nil), Hash)
@@ -10047,14 +10239,16 @@ class RuboCop::Cop::VariableForce::VariableReference < ::Struct
   def name; end
   def name=(_); end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RuboCop::Cop::VariableForce::VariableTable
-  def initialize(hook_receiver = _); end
+  def initialize(hook_receiver = T.unsafe(nil)); end
 
   def accessible_variables; end
   def assign_to_variable(name, node); end
@@ -10079,7 +10273,7 @@ RuboCop::Cop::VariableForce::ZERO_ARITY_SUPER_TYPE = T.let(T.unsafe(nil), Symbol
 module RuboCop::Cop::VisibilityHelp
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def visibility_block?(node = _); end
+  def visibility_block?(node = T.unsafe(nil)); end
 
   private
 
@@ -10115,15 +10309,17 @@ module RuboCop::Ext::ProcessedSource
 end
 
 module RuboCop::FileFinder
-  def find_file_upwards(filename, start_dir, stop_dir = _); end
-  def find_last_file_upwards(filename, start_dir, stop_dir = _); end
+  def find_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end
+  def find_last_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end
 
   private
 
   def traverse_files_upwards(filename, start_dir, stop_dir); end
 
-  def self.root_level=(level); end
-  def self.root_level?(path, stop_dir); end
+  class << self
+    def root_level=(level); end
+    def root_level?(path, stop_dir); end
+  end
 end
 
 module RuboCop::Formatter
@@ -10134,7 +10330,7 @@ class RuboCop::Formatter::AutoGenConfigFormatter < ::RuboCop::Formatter::Progres
 end
 
 class RuboCop::Formatter::BaseFormatter
-  def initialize(output, options = _); end
+  def initialize(output, options = T.unsafe(nil)); end
 
   def file_finished(file, offenses); end
   def file_started(file, options); end
@@ -10171,7 +10367,7 @@ module RuboCop::Formatter::Colorizable
 end
 
 class RuboCop::Formatter::DisabledConfigFormatter < ::RuboCop::Formatter::BaseFormatter
-  def initialize(output, options = _); end
+  def initialize(output, options = T.unsafe(nil)); end
 
   def file_finished(file, offenses); end
   def file_started(_file, _file_info); end
@@ -10194,10 +10390,12 @@ class RuboCop::Formatter::DisabledConfigFormatter < ::RuboCop::Formatter::BaseFo
   def set_max(cfg, cop_name); end
   def timestamp; end
 
-  def self.config_to_allow_offenses; end
-  def self.config_to_allow_offenses=(_); end
-  def self.detected_styles; end
-  def self.detected_styles=(_); end
+  class << self
+    def config_to_allow_offenses; end
+    def config_to_allow_offenses=(_); end
+    def detected_styles; end
+    def detected_styles=(_); end
+  end
 end
 
 RuboCop::Formatter::DisabledConfigFormatter::HEADING = T.let(T.unsafe(nil), String)
@@ -10215,9 +10413,9 @@ class RuboCop::Formatter::FileListFormatter < ::RuboCop::Formatter::BaseFormatte
 end
 
 class RuboCop::Formatter::FormatterSet < ::Array
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
-  def add_formatter(formatter_type, output_path = _); end
+  def add_formatter(formatter_type, output_path = T.unsafe(nil)); end
   def close_output_files; end
   def file_finished(file, offenses); end
   def file_started(file, options); end
@@ -10248,7 +10446,7 @@ end
 RuboCop::Formatter::FuubarStyleFormatter::RESET_SEQUENCE = T.let(T.unsafe(nil), String)
 
 class RuboCop::Formatter::HTMLFormatter < ::RuboCop::Formatter::BaseFormatter
-  def initialize(output, options = _); end
+  def initialize(output, options = T.unsafe(nil)); end
 
   def file_finished(file, offenses); end
   def files; end
@@ -10270,10 +10468,12 @@ class RuboCop::Formatter::HTMLFormatter::Color < ::Struct
   def red=(_); end
   def to_s; end
 
-  def self.[](*_); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*_); end
+  class << self
+    def [](*_); end
+    def inspect; end
+    def members; end
+    def new(*_); end
+  end
 end
 
 RuboCop::Formatter::HTMLFormatter::ELLIPSES = T.let(T.unsafe(nil), String)
@@ -10306,7 +10506,7 @@ RuboCop::Formatter::HTMLFormatter::TEMPLATE_PATH = T.let(T.unsafe(nil), String)
 class RuboCop::Formatter::JSONFormatter < ::RuboCop::Formatter::BaseFormatter
   include(::RuboCop::PathUtil)
 
-  def initialize(output, options = _); end
+  def initialize(output, options = T.unsafe(nil)); end
 
   def file_finished(file, offenses); end
   def finished(inspected_files); end
@@ -10319,7 +10519,7 @@ class RuboCop::Formatter::JSONFormatter < ::RuboCop::Formatter::BaseFormatter
 end
 
 class RuboCop::Formatter::JUnitFormatter < ::RuboCop::Formatter::BaseFormatter
-  def initialize(output, options = _); end
+  def initialize(output, options = T.unsafe(nil)); end
 
   def classname_attribute_value(file); end
   def file_finished(file, offenses); end
@@ -10345,7 +10545,7 @@ end
 class RuboCop::Formatter::PacmanFormatter < ::RuboCop::Formatter::ClangStyleFormatter
   include(::RuboCop::Formatter::TextUtil)
 
-  def initialize(output, options = _); end
+  def initialize(output, options = T.unsafe(nil)); end
 
   def cols; end
   def file_finished(file, offenses); end
@@ -10370,7 +10570,7 @@ RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::Pres
 class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter
   include(::RuboCop::Formatter::TextUtil)
 
-  def initialize(output, options = _); end
+  def initialize(output, options = T.unsafe(nil)); end
 
   def file_finished(file, offenses); end
   def finished(inspected_files); end
@@ -10437,9 +10637,11 @@ module RuboCop::Formatter::TextUtil
 
   private
 
-  def pluralize(number, thing, options = _); end
+  def pluralize(number, thing, options = T.unsafe(nil)); end
 
-  def self.pluralize(number, thing, options = _); end
+  class << self
+    def pluralize(number, thing, options = T.unsafe(nil)); end
+  end
 end
 
 class RuboCop::Formatter::WorstOffendersFormatter < ::RuboCop::Formatter::BaseFormatter
@@ -10470,7 +10672,9 @@ class RuboCop::MagicComment
   def extract(pattern); end
   def specified?(value); end
 
-  def self.parse(comment); end
+  class << self
+    def parse(comment); end
+  end
 end
 
 class RuboCop::MagicComment::EditorComment < ::RuboCop::MagicComment
@@ -10523,8 +10727,10 @@ module RuboCop::NameSimilarity
   def find_similar_name(target_name, names); end
   def find_similar_names(target_name, names); end
 
-  def self.find_similar_name(target_name, names); end
-  def self.find_similar_names(target_name, names); end
+  class << self
+    def find_similar_name(target_name, names); end
+    def find_similar_names(target_name, names); end
+  end
 end
 
 RuboCop::NodePattern = RuboCop::AST::NodePattern
@@ -10588,7 +10794,13 @@ class RuboCop::OptionsValidator
   def validate_parallel; end
   def validate_parallel_with_combo_option; end
 
-  def self.validate_cop_list(names); end
+  class << self
+    def validate_cop_list(names); end
+
+    private
+
+    def format_message_from(name, cop_names); end
+  end
 end
 
 module RuboCop::PathUtil
@@ -10599,19 +10811,23 @@ module RuboCop::PathUtil
   def hidden_dir?(path); end
   def hidden_file_in_not_hidden_dir?(pattern, path); end
   def match_path?(pattern, path); end
-  def relative_path(path, base_dir = _); end
+  def relative_path(path, base_dir = T.unsafe(nil)); end
   def smart_path(path); end
 
-  def self.absolute?(path); end
-  def self.hidden_dir?(path); end
-  def self.hidden_file_in_not_hidden_dir?(pattern, path); end
-  def self.match_path?(pattern, path); end
-  def self.relative_path(path, base_dir = _); end
-  def self.smart_path(path); end
+  class << self
+    def absolute?(path); end
+    def hidden_dir?(path); end
+    def hidden_file_in_not_hidden_dir?(pattern, path); end
+    def match_path?(pattern, path); end
+    def relative_path(path, base_dir = T.unsafe(nil)); end
+    def smart_path(path); end
+  end
 end
 
 module RuboCop::Platform
-  def self.windows?; end
+  class << self
+    def windows?; end
+  end
 end
 
 RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
@@ -10631,13 +10847,13 @@ class RuboCop::RemoteConfig
   def cache_path_expired?; end
   def generate_request(uri); end
   def handle_response(response, limit, &block); end
-  def request(uri = _, limit = _, &block); end
+  def request(uri = T.unsafe(nil), limit = T.unsafe(nil), &block); end
 end
 
 RuboCop::RemoteConfig::CACHE_LIFETIME = T.let(T.unsafe(nil), Integer)
 
 class RuboCop::ResultCache
-  def initialize(file, team, options, config_store, cache_root = _); end
+  def initialize(file, team, options, config_store, cache_root = T.unsafe(nil)); end
 
   def load; end
   def save(offenses); end
@@ -10653,13 +10869,21 @@ class RuboCop::ResultCache
   def symlink_protection_triggered?(path); end
   def team_checksum(team); end
 
-  def self.allow_symlinks_in_cache_location?(config_store); end
-  def self.cache_root(config_store); end
-  def self.cleanup(config_store, verbose, cache_root = _); end
-  def self.inhibit_cleanup; end
-  def self.inhibit_cleanup=(_); end
-  def self.source_checksum; end
-  def self.source_checksum=(_); end
+  class << self
+    def allow_symlinks_in_cache_location?(config_store); end
+    def cache_root(config_store); end
+    def cleanup(config_store, verbose, cache_root = T.unsafe(nil)); end
+    def inhibit_cleanup; end
+    def inhibit_cleanup=(_); end
+    def source_checksum; end
+    def source_checksum=(_); end
+
+    private
+
+    def remove_files(files, dirs, remove_count); end
+    def remove_oldest_files(files, dirs, cache_root, verbose); end
+    def requires_file_removal?(file_count, config_store); end
+  end
 end
 
 RuboCop::ResultCache::NON_CHANGING = T.let(T.unsafe(nil), Array)
@@ -10692,7 +10916,7 @@ class RuboCop::Runner
   def find_target_files(paths); end
   def formatter_set; end
   def get_processed_source(file); end
-  def inspect_file(processed_source, team = _); end
+  def inspect_file(processed_source, team = T.unsafe(nil)); end
   def inspect_files(files); end
   def iterate_until_no_changes(source, offenses); end
   def list_files(paths); end
@@ -10717,7 +10941,16 @@ end
 RuboCop::Runner::MAX_ITERATIONS = T.let(T.unsafe(nil), Integer)
 
 class RuboCop::StringInterpreter
-  def self.interpret(string); end
+  class << self
+    def interpret(string); end
+
+    private
+
+    def interpret_hex(escape); end
+    def interpret_octal(escape); end
+    def interpret_string_escape(escape); end
+    def interpret_unicode(escape); end
+  end
 end
 
 RuboCop::StringInterpreter::STRING_ESCAPES = T.let(T.unsafe(nil), Hash)
@@ -10725,7 +10958,7 @@ RuboCop::StringInterpreter::STRING_ESCAPES = T.let(T.unsafe(nil), Hash)
 RuboCop::StringInterpreter::STRING_ESCAPE_REGEX = T.let(T.unsafe(nil), Regexp)
 
 class RuboCop::TargetFinder
-  def initialize(config_store, options = _); end
+  def initialize(config_store, options = T.unsafe(nil)); end
 
   def all_cops_include; end
   def configured_include?(file); end
@@ -10745,7 +10978,7 @@ class RuboCop::TargetFinder
   def ruby_filenames; end
   def ruby_interpreters(file); end
   def stdin?; end
-  def target_files_in_dir(base_dir = _); end
+  def target_files_in_dir(base_dir = T.unsafe(nil)); end
   def to_inspect?(file, hidden_files, base_dir_config); end
   def toplevel_dirs(base_dir, flags); end
 
@@ -10762,7 +10995,9 @@ class RuboCop::TargetRuby
   def supported?; end
   def version; end
 
-  def self.supported_versions; end
+  class << self
+    def supported_versions; end
+  end
 end
 
 class RuboCop::TargetRuby::BundlerLockFile < ::RuboCop::TargetRuby::Source
@@ -10817,7 +11052,9 @@ class RuboCop::ValidationError < ::RuboCop::Error
 end
 
 module RuboCop::Version
-  def self.version(debug = _); end
+  class << self
+    def version(debug = T.unsafe(nil)); end
+  end
 end
 
 RuboCop::Version::MSG = T.let(T.unsafe(nil), String)
@@ -10828,7 +11065,13 @@ class RuboCop::Warning < ::StandardError
 end
 
 module RuboCop::YAMLDuplicationChecker
-  def self.check(yaml_string, filename, &on_duplicated); end
+  class << self
+    def check(yaml_string, filename, &on_duplicated); end
+
+    private
+
+    def traverse(tree, &on_duplicated); end
+  end
 end
 
 class String
diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi
index 27b1fb4bc6..b3235ad9fc 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ruby-macho` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi
index baaaa5b2fc..fa0d4a7bc5 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi
@@ -1,16 +1,19 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ruby-progressbar` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 class ProgressBar
-  def self.create(*args); end
+  class << self
+    def create(*args); end
+  end
 end
 
 class ProgressBar::Base
   extend(::Forwardable)
 
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def clear(*args, &block); end
   def decrement; end
@@ -30,14 +33,14 @@ class ProgressBar::Base
   def remainder_mark=(mark); end
   def reset; end
   def resume; end
-  def start(options = _); end
+  def start(options = T.unsafe(nil)); end
   def started?; end
   def stop; end
   def stopped?; end
   def title; end
   def title=(title); end
   def to_h; end
-  def to_s(new_format = _); end
+  def to_s(new_format = T.unsafe(nil)); end
   def total(*args, &block); end
   def total=(new_total); end
 
@@ -72,7 +75,7 @@ module ProgressBar::Calculators
 end
 
 class ProgressBar::Calculators::Length
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def calculate_length; end
   def current_length; end
@@ -98,14 +101,16 @@ class ProgressBar::Calculators::Length
 end
 
 class ProgressBar::Calculators::RunningAverage
-  def self.calculate(current_average, new_value_to_average, smoothing_factor); end
+  class << self
+    def calculate(current_average, new_value_to_average, smoothing_factor); end
+  end
 end
 
 module ProgressBar::Components
 end
 
 class ProgressBar::Components::Bar
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def length; end
   def length=(_); end
@@ -115,7 +120,7 @@ class ProgressBar::Components::Bar
   def progress_mark=(_); end
   def remainder_mark; end
   def remainder_mark=(_); end
-  def to_s(options = _); end
+  def to_s(options = T.unsafe(nil)); end
   def upa_steps; end
   def upa_steps=(_); end
 
@@ -141,7 +146,7 @@ ProgressBar::Components::Bar::DEFAULT_REMAINDER_MARK = T.let(T.unsafe(nil), Stri
 ProgressBar::Components::Bar::DEFAULT_UPA_STEPS = T.let(T.unsafe(nil), Array)
 
 class ProgressBar::Components::Percentage
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def progress; end
   def progress=(_); end
@@ -155,7 +160,7 @@ class ProgressBar::Components::Percentage
 end
 
 class ProgressBar::Components::Rate
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def progress; end
   def progress=(_); end
@@ -172,13 +177,13 @@ class ProgressBar::Components::Rate
 
   def base_rate; end
   def elapsed_seconds; end
-  def rate_of_change(format_string = _); end
+  def rate_of_change(format_string = T.unsafe(nil)); end
   def rate_of_change_with_precision; end
   def scaled_rate; end
 end
 
 class ProgressBar::Components::Time
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def elapsed_with_label; end
   def estimated_with_label; end
@@ -221,7 +226,7 @@ ProgressBar::Components::Time::OOB_UNKNOWN_TIME_TEXT = T.let(T.unsafe(nil), Stri
 ProgressBar::Components::Time::TIME_FORMAT = T.let(T.unsafe(nil), String)
 
 class ProgressBar::Components::Title
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def title; end
   def title=(_); end
@@ -233,7 +238,9 @@ module ProgressBar::Format
 end
 
 class ProgressBar::Format::Formatter
-  def self.process(format_string, max_length, bar); end
+  class << self
+    def process(format_string, max_length, bar); end
+  end
 end
 
 class ProgressBar::Format::Molecule
@@ -243,7 +250,7 @@ class ProgressBar::Format::Molecule
   def full_key; end
   def key; end
   def key=(_); end
-  def lookup_value(environment, length = _); end
+  def lookup_value(environment, length = T.unsafe(nil)); end
   def method_name; end
   def method_name=(_); end
   def non_bar_molecule?; end
@@ -269,12 +276,12 @@ class ProgressBar::InvalidProgressError < ::RuntimeError
 end
 
 class ProgressBar::Output
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def clear_string; end
   def length; end
   def log(string); end
-  def refresh(options = _); end
+  def refresh(options = T.unsafe(nil)); end
   def stream; end
   def stream=(_); end
   def with_refresh; end
@@ -292,7 +299,9 @@ class ProgressBar::Output
 
   def print_and_flush; end
 
-  def self.detect(options = _); end
+  class << self
+    def detect(options = T.unsafe(nil)); end
+  end
 end
 
 ProgressBar::Output::DEFAULT_OUTPUT_STREAM = T.let(T.unsafe(nil), IO)
@@ -328,7 +337,7 @@ end
 ProgressBar::Outputs::Tty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String)
 
 class ProgressBar::Progress
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def absolute; end
   def decrement; end
@@ -345,7 +354,7 @@ class ProgressBar::Progress
   def running_average=(_); end
   def smoothing; end
   def smoothing=(_); end
-  def start(options = _); end
+  def start(options = T.unsafe(nil)); end
   def starting_position; end
   def starting_position=(_); end
   def total; end
@@ -367,9 +376,9 @@ module ProgressBar::Refinements::Enumerator
 end
 
 class ProgressBar::Throttle
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
-  def choke(options = _); end
+  def choke(options = T.unsafe(nil)); end
   def rate; end
   def rate=(_); end
   def started_at; end
@@ -381,7 +390,7 @@ class ProgressBar::Throttle
 end
 
 class ProgressBar::Time
-  def initialize(time = _); end
+  def initialize(time = T.unsafe(nil)); end
 
   def now; end
   def unmocked_time_method; end
@@ -395,7 +404,7 @@ end
 ProgressBar::Time::TIME_MOCKING_LIBRARY_METHODS = T.let(T.unsafe(nil), Array)
 
 class ProgressBar::Timer
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def divide_seconds(seconds); end
   def elapsed_seconds; end
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.2.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.2.rbi
index 198c6b42fc..cf8382d5d7 100644
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.2.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `simplecov-html` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.18.5.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.18.5.rbi
index 198c6b42fc..1b380080bf 100644
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.18.5.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.18.5.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `simplecov` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi b/Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi
index 9b80e20809..a623054e22 100644
--- a/Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `thor` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -10,52 +11,74 @@ class Thor
   extend(::Thor::Base::ClassMethods)
   extend(::Thor::Invocation::ClassMethods)
 
-  def help(command = _, subcommand = _); end
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
 
-  def self.check_unknown_options!(options = _); end
-  def self.check_unknown_options?(config); end
-  def self.command_help(shell, command_name); end
-  def self.default_command(meth = _); end
-  def self.default_task(meth = _); end
-  def self.deprecation_warning(message); end
-  def self.desc(usage, description, options = _); end
-  def self.disable_required_check!(*command_names); end
-  def self.disable_required_check?(command); end
-  def self.help(shell, subcommand = _); end
-  def self.long_desc(long_description, options = _); end
-  def self.map(mappings = _, **kw); end
-  def self.method_option(name, options = _); end
-  def self.method_options(options = _); end
-  def self.option(name, options = _); end
-  def self.options(options = _); end
-  def self.package_name(name, _ = _); end
-  def self.printable_commands(all = _, subcommand = _); end
-  def self.printable_tasks(all = _, subcommand = _); end
-  def self.register(klass, subcommand_name, usage, description, options = _); end
-  def self.stop_on_unknown_option!(*command_names); end
-  def self.stop_on_unknown_option?(command); end
-  def self.subcommand(subcommand, subcommand_class); end
-  def self.subcommand_classes; end
-  def self.subcommands; end
-  def self.subtask(subcommand, subcommand_class); end
-  def self.subtasks; end
-  def self.task_help(shell, command_name); end
+  class << self
+    def check_unknown_options!(options = T.unsafe(nil)); end
+    def check_unknown_options?(config); end
+    def command_help(shell, command_name); end
+    def default_command(meth = T.unsafe(nil)); end
+    def default_task(meth = T.unsafe(nil)); end
+    def deprecation_warning(message); end
+    def desc(usage, description, options = T.unsafe(nil)); end
+    def disable_required_check!(*command_names); end
+    def disable_required_check?(command); end
+    def help(shell, subcommand = T.unsafe(nil)); end
+    def long_desc(long_description, options = T.unsafe(nil)); end
+    def map(mappings = T.unsafe(nil), **kw); end
+    def method_option(name, options = T.unsafe(nil)); end
+    def method_options(options = T.unsafe(nil)); end
+    def option(name, options = T.unsafe(nil)); end
+    def options(options = T.unsafe(nil)); end
+    def package_name(name, _ = T.unsafe(nil)); end
+    def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+    def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+    def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end
+    def stop_on_unknown_option!(*command_names); end
+    def stop_on_unknown_option?(command); end
+    def subcommand(subcommand, subcommand_class); end
+    def subcommand_classes; end
+    def subcommands; end
+    def subtask(subcommand, subcommand_class); end
+    def subtasks; end
+    def task_help(shell, command_name); end
+
+    protected
+
+    def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+    def baseclass; end
+    def create_command(meth); end
+    def create_task(meth); end
+    def disable_required_check; end
+    def dispatch(meth, given_args, given_opts, config); end
+    def dynamic_command_class; end
+    def find_command_possibilities(meth); end
+    def find_task_possibilities(meth); end
+    def initialize_added; end
+    def normalize_command_name(meth); end
+    def normalize_task_name(meth); end
+    def retrieve_command_name(args); end
+    def retrieve_task_name(args); end
+    def stop_on_unknown_option; end
+    def subcommand_help(cmd); end
+    def subtask_help(cmd); end
+  end
 end
 
 module Thor::Actions
   mixes_in_class_methods(::Thor::Actions::ClassMethods)
 
-  def initialize(args = _, options = _, config = _); end
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
 
   def action(instance); end
   def add_file(destination, *args, &block); end
   def add_link(destination, *args); end
   def append_file(path, *args, &block); end
   def append_to_file(path, *args, &block); end
-  def apply(path, config = _); end
+  def apply(path, config = T.unsafe(nil)); end
   def behavior; end
   def behavior=(_); end
-  def chmod(path, mode, config = _); end
+  def chmod(path, mode, config = T.unsafe(nil)); end
   def comment_lines(path, flag, *args); end
   def copy_file(source, *args, &block); end
   def create_file(destination, *args, &block); end
@@ -63,7 +86,7 @@ module Thor::Actions
   def destination_root; end
   def destination_root=(root); end
   def directory(source, *args, &block); end
-  def empty_directory(destination, config = _); end
+  def empty_directory(destination, config = T.unsafe(nil)); end
   def find_in_source_paths(file); end
   def get(source, *args, &block); end
   def gsub_file(path, flag, *args, &block); end
@@ -72,15 +95,15 @@ module Thor::Actions
   def inject_into_file(destination, *args, &block); end
   def inject_into_module(path, module_name, *args, &block); end
   def insert_into_file(destination, *args, &block); end
-  def inside(dir = _, config = _, &block); end
+  def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end
   def link_file(source, *args); end
   def prepend_file(path, *args, &block); end
   def prepend_to_file(path, *args, &block); end
-  def relative_to_original_destination_root(path, remove_dot = _); end
-  def remove_dir(path, config = _); end
-  def remove_file(path, config = _); end
-  def run(command, config = _); end
-  def run_ruby_script(command, config = _); end
+  def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end
+  def remove_dir(path, config = T.unsafe(nil)); end
+  def remove_file(path, config = T.unsafe(nil)); end
+  def run(command, config = T.unsafe(nil)); end
+  def run_ruby_script(command, config = T.unsafe(nil)); end
   def source_paths; end
   def template(source, *args, &block); end
   def thor(command, *args); end
@@ -97,24 +120,26 @@ module Thor::Actions
   def concat(string); end
   def output_buffer; end
   def output_buffer=(_); end
-  def with_output_buffer(buf = _); end
+  def with_output_buffer(buf = T.unsafe(nil)); end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 class Thor::Actions::CapturableERB < ::ERB
-  def set_eoutvar(compiler, eoutvar = _); end
+  def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end
 end
 
 module Thor::Actions::ClassMethods
   def add_runtime_options!; end
   def source_paths; end
   def source_paths_for_search; end
-  def source_root(path = _); end
+  def source_root(path = T.unsafe(nil)); end
 end
 
 class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory
-  def initialize(base, destination, data, config = _); end
+  def initialize(base, destination, data, config = T.unsafe(nil)); end
 
   def data; end
   def identical?; end
@@ -136,7 +161,7 @@ class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile
 end
 
 class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
-  def initialize(base, source, destination = _, config = _, &block); end
+  def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end
 
   def invoke!; end
   def revoke!; end
@@ -150,7 +175,7 @@ class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
 end
 
 class Thor::Actions::EmptyDirectory
-  def initialize(base, destination, config = _); end
+  def initialize(base, destination, config = T.unsafe(nil)); end
 
   def base; end
   def config; end
@@ -184,7 +209,7 @@ class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
   protected
 
   def replace!(regexp, string, force); end
-  def say_status(behavior, warning: _, color: _); end
+  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
 end
 
 Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash)
@@ -195,7 +220,7 @@ end
 Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
 
 class Thor::Argument
-  def initialize(name, options = _); end
+  def initialize(name, options = T.unsafe(nil)); end
 
   def banner; end
   def default; end
@@ -219,7 +244,7 @@ end
 Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array)
 
 class Thor::Arguments
-  def initialize(arguments = _); end
+  def initialize(arguments = T.unsafe(nil)); end
 
   def parse(args); end
   def remaining; end
@@ -238,8 +263,10 @@ class Thor::Arguments
   def shift; end
   def unshift(arg); end
 
-  def self.parse(*args); end
-  def self.split(args); end
+  class << self
+    def parse(*args); end
+    def split(args); end
+  end
 end
 
 Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
@@ -250,7 +277,7 @@ module Thor::Base
 
   mixes_in_class_methods(::Thor::Base::ClassMethods)
 
-  def initialize(args = _, local_options = _, config = _); end
+  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
 
   def args; end
   def args=(_); end
@@ -259,19 +286,21 @@ module Thor::Base
   def parent_options; end
   def parent_options=(_); end
 
-  def self.included(base); end
-  def self.register_klass_file(klass); end
-  def self.shell; end
-  def self.shell=(_); end
-  def self.subclass_files; end
-  def self.subclasses; end
+  class << self
+    def included(base); end
+    def register_klass_file(klass); end
+    def shell; end
+    def shell=(_); end
+    def subclass_files; end
+    def subclasses; end
+  end
 end
 
 module Thor::Base::ClassMethods
   def all_commands; end
   def all_tasks; end
   def allow_incompatible_default_type!; end
-  def argument(name, options = _); end
+  def argument(name, options = T.unsafe(nil)); end
   def arguments; end
   def attr_accessor(*_); end
   def attr_reader(*_); end
@@ -281,16 +310,16 @@ module Thor::Base::ClassMethods
   def check_unknown_options; end
   def check_unknown_options!; end
   def check_unknown_options?(config); end
-  def class_option(name, options = _); end
-  def class_options(options = _); end
+  def class_option(name, options = T.unsafe(nil)); end
+  def class_options(options = T.unsafe(nil)); end
   def commands; end
   def disable_required_check?(command_name); end
   def exit_on_failure?; end
-  def group(name = _); end
+  def group(name = T.unsafe(nil)); end
   def handle_argument_error(command, error, args, arity); end
-  def handle_no_command_error(command, has_namespace = _); end
-  def handle_no_task_error(command, has_namespace = _); end
-  def namespace(name = _); end
+  def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end
+  def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end
+  def namespace(name = T.unsafe(nil)); end
   def no_commands(&block); end
   def no_commands?; end
   def no_commands_context; end
@@ -301,7 +330,7 @@ module Thor::Base::ClassMethods
   def remove_class_option(*names); end
   def remove_command(*names); end
   def remove_task(*names); end
-  def start(given_args = _, config = _); end
+  def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end
   def stop_on_unknown_option?(command_name); end
   def strict_args_position; end
   def strict_args_position!; end
@@ -314,26 +343,26 @@ module Thor::Base::ClassMethods
   def basename; end
   def build_option(name, options, scope); end
   def build_options(options, scope); end
-  def class_options_help(shell, groups = _); end
+  def class_options_help(shell, groups = T.unsafe(nil)); end
   def create_command(meth); end
   def create_task(meth); end
   def dispatch(command, given_args, given_opts, config); end
   def find_and_refresh_command(name); end
   def find_and_refresh_task(name); end
-  def from_superclass(method, default = _); end
+  def from_superclass(method, default = T.unsafe(nil)); end
   def inherited(klass); end
   def initialize_added; end
   def is_thor_reserved_word?(word, type); end
   def method_added(meth); end
-  def print_options(shell, options, group_name = _); end
+  def print_options(shell, options, group_name = T.unsafe(nil)); end
 end
 
 class Thor::Command < ::Struct
-  def initialize(name, description, long_description, usage, options = _); end
+  def initialize(name, description, long_description, usage, options = T.unsafe(nil)); end
 
-  def formatted_usage(klass, namespace = _, subcommand = _); end
+  def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
   def hidden?; end
-  def run(instance, args = _); end
+  def run(instance, args = T.unsafe(nil)); end
 
   protected
 
@@ -358,7 +387,7 @@ module Thor::CoreExt
 end
 
 class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
-  def initialize(hash = _); end
+  def initialize(hash = T.unsafe(nil)); end
 
   def [](key); end
   def []=(key, value); end
@@ -382,9 +411,9 @@ end
 Thor::Correctable = DidYouMean::Correctable
 
 class Thor::DynamicCommand < ::Thor::Command
-  def initialize(name, options = _); end
+  def initialize(name, options = T.unsafe(nil)); end
 
-  def run(instance, args = _); end
+  def run(instance, args = T.unsafe(nil)); end
 end
 
 Thor::DynamicTask = Thor::DynamicCommand
@@ -402,20 +431,32 @@ class Thor::Group
 
   protected
 
-  def _invoke_for_class_method(klass, command = _, *args, &block); end
+  def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end
 
-  def self.class_options_help(shell, groups = _); end
-  def self.desc(description = _); end
-  def self.get_options_from_invocations(group_options, base_options); end
-  def self.handle_argument_error(command, error, _args, arity); end
-  def self.help(shell); end
-  def self.invocation_blocks; end
-  def self.invocations; end
-  def self.invoke(*names, &block); end
-  def self.invoke_from_option(*names, &block); end
-  def self.printable_commands(*_); end
-  def self.printable_tasks(*_); end
-  def self.remove_invocation(*names); end
+  class << self
+    def class_options_help(shell, groups = T.unsafe(nil)); end
+    def desc(description = T.unsafe(nil)); end
+    def get_options_from_invocations(group_options, base_options); end
+    def handle_argument_error(command, error, _args, arity); end
+    def help(shell); end
+    def invocation_blocks; end
+    def invocations; end
+    def invoke(*names, &block); end
+    def invoke_from_option(*names, &block); end
+    def printable_commands(*_); end
+    def printable_tasks(*_); end
+    def remove_invocation(*names); end
+
+    protected
+
+    def banner; end
+    def baseclass; end
+    def create_command(meth); end
+    def create_task(meth); end
+    def dispatch(command, given_args, given_opts, config); end
+    def self_command; end
+    def self_task; end
+  end
 end
 
 Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array)
@@ -429,10 +470,10 @@ Thor::HiddenTask = Thor::HiddenCommand
 module Thor::Invocation
   mixes_in_class_methods(::Thor::Invocation::ClassMethods)
 
-  def initialize(args = _, options = _, config = _, &block); end
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end
 
   def current_command_chain; end
-  def invoke(name = _, *args); end
+  def invoke(name = T.unsafe(nil), *args); end
   def invoke_all; end
   def invoke_command(command, *args); end
   def invoke_task(command, *args); end
@@ -441,11 +482,13 @@ module Thor::Invocation
   protected
 
   def _parse_initialization_options(args, opts, config); end
-  def _retrieve_class_and_command(name, sent_command = _); end
-  def _retrieve_class_and_task(name, sent_command = _); end
+  def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end
+  def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end
   def _shared_configuration; end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 module Thor::Invocation::ClassMethods
@@ -456,8 +499,10 @@ class Thor::InvocationError < ::Thor::Error
 end
 
 module Thor::LineEditor
-  def self.best_available; end
-  def self.readline(prompt, options = _); end
+  class << self
+    def best_available; end
+    def readline(prompt, options = T.unsafe(nil)); end
+  end
 end
 
 class Thor::LineEditor::Basic
@@ -472,7 +517,9 @@ class Thor::LineEditor::Basic
   def echo?; end
   def get_input; end
 
-  def self.available?; end
+  class << self
+    def available?; end
+  end
 end
 
 class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
@@ -485,7 +532,9 @@ class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
   def completion_proc; end
   def use_path_completion?; end
 
-  def self.available?; end
+  class << self
+    def available?; end
+  end
 end
 
 class Thor::LineEditor::Readline::PathCompletion
@@ -522,7 +571,7 @@ class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker
 end
 
 class Thor::Option < ::Thor::Argument
-  def initialize(name, options = _); end
+  def initialize(name, options = T.unsafe(nil)); end
 
   def aliases; end
   def array?; end
@@ -536,7 +585,7 @@ class Thor::Option < ::Thor::Argument
   def repeatable; end
   def string?; end
   def switch_name; end
-  def usage(padding = _); end
+  def usage(padding = T.unsafe(nil)); end
 
   protected
 
@@ -546,13 +595,15 @@ class Thor::Option < ::Thor::Argument
   def validate!; end
   def validate_default_type!; end
 
-  def self.parse(key, value); end
+  class << self
+    def parse(key, value); end
+  end
 end
 
 Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array)
 
 class Thor::Options < ::Thor::Arguments
-  def initialize(hash_options = _, defaults = _, stop_on_unknown = _, disable_required_check = _); end
+  def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil)); end
 
   def check_unknown!; end
   def parse(args); end
@@ -572,7 +623,9 @@ class Thor::Options < ::Thor::Arguments
   def switch?(arg); end
   def switch_option(arg); end
 
-  def self.to_switches(options); end
+  class << self
+    def to_switches(options); end
+  end
 end
 
 Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
@@ -594,7 +647,7 @@ module Thor::Sandbox
 end
 
 module Thor::Shell
-  def initialize(args = _, options = _, config = _); end
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
 
   def ask(*args, &block); end
   def error(*args, &block); end
@@ -625,20 +678,20 @@ class Thor::Shell::Basic
   def base=(_); end
   def error(statement); end
   def file_collision(destination); end
-  def indent(count = _); end
+  def indent(count = T.unsafe(nil)); end
   def mute; end
   def mute?; end
-  def no?(statement, color = _); end
+  def no?(statement, color = T.unsafe(nil)); end
   def padding; end
   def padding=(value); end
   def print_in_columns(array); end
-  def print_table(array, options = _); end
-  def print_wrapped(message, options = _); end
-  def say(message = _, color = _, force_new_line = _); end
-  def say_status(status, message, log_status = _); end
+  def print_table(array, options = T.unsafe(nil)); end
+  def print_wrapped(message, options = T.unsafe(nil)); end
+  def say(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
+  def say_status(status, message, log_status = T.unsafe(nil)); end
   def set_color(string, *_); end
   def terminal_width; end
-  def yes?(statement, color = _); end
+  def yes?(statement, color = T.unsafe(nil)); end
 
   protected
 
@@ -716,7 +769,7 @@ Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String)
 Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String)
 
 class Thor::Shell::HTML < ::Thor::Shell::Basic
-  def ask(statement, color = _); end
+  def ask(statement, color = T.unsafe(nil)); end
   def set_color(string, *colors); end
 
   protected
@@ -806,20 +859,22 @@ class Thor::UnknownArgumentError::SpellChecker
 end
 
 module Thor::Util
-  def self.camel_case(str); end
-  def self.escape_globs(path); end
-  def self.escape_html(string); end
-  def self.find_by_namespace(namespace); end
-  def self.find_class_and_command_by_namespace(namespace, fallback = _); end
-  def self.find_class_and_task_by_namespace(namespace, fallback = _); end
-  def self.globs_for(path); end
-  def self.load_thorfile(path, content = _, debug = _); end
-  def self.namespace_from_thor_class(constant); end
-  def self.namespaces_in_content(contents, file = _); end
-  def self.ruby_command; end
-  def self.snake_case(str); end
-  def self.thor_classes_in(klass); end
-  def self.thor_root; end
-  def self.thor_root_glob; end
-  def self.user_home; end
+  class << self
+    def camel_case(str); end
+    def escape_globs(path); end
+    def escape_html(string); end
+    def find_by_namespace(namespace); end
+    def find_class_and_command_by_namespace(namespace, fallback = T.unsafe(nil)); end
+    def find_class_and_task_by_namespace(namespace, fallback = T.unsafe(nil)); end
+    def globs_for(path); end
+    def load_thorfile(path, content = T.unsafe(nil), debug = T.unsafe(nil)); end
+    def namespace_from_thor_class(constant); end
+    def namespaces_in_content(contents, file = T.unsafe(nil)); end
+    def ruby_command; end
+    def snake_case(str); end
+    def thor_classes_in(klass); end
+    def thor_root; end
+    def thor_root_glob; end
+    def user_home; end
+  end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi b/Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi
index 27b1fb4bc6..9318de64af 100644
--- a/Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `thread_safe` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi b/Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi
index 27b1fb4bc6..fca7e051ee 100644
--- a/Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `tzinfo` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi b/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi
index 2d49ec540f..a2cfbfcffa 100644
--- a/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `unf` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -14,8 +15,10 @@ class UNF::Normalizer
 
   def normalize(_, _); end
 
-  def self.instance; end
-  def self.normalize(string, form); end
+  class << self
+    def instance; end
+    def normalize(string, form); end
+  end
 end
 
 UNF::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi b/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi
index 27b1fb4bc6..97d63e9dd5 100644
--- a/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `unf_ext` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi b/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi
index 90001fa9fa..742f7bb3e3 100644
--- a/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `unicode-display_width` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -7,8 +8,10 @@ module Unicode
 end
 
 module Unicode::DisplayWidth
-  def self.emoji_extra_width_of(string, ambiguous = _, overwrite = _, _ = _); end
-  def self.of(string, ambiguous = _, overwrite = _, options = _); end
+  class << self
+    def emoji_extra_width_of(string, ambiguous = T.unsafe(nil), overwrite = T.unsafe(nil), _ = T.unsafe(nil)); end
+    def of(string, ambiguous = T.unsafe(nil), overwrite = T.unsafe(nil), options = T.unsafe(nil)); end
+  end
 end
 
 Unicode::DisplayWidth::DATA_DIRECTORY = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi b/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi
index f8d2990806..ce20390b7d 100644
--- a/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi
@@ -1,16 +1,17 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `webrobots` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
-  def fragment(tags = _); end
+  def fragment(tags = T.unsafe(nil)); end
   def meta_encoding; end
   def meta_encoding=(encoding); end
-  def meta_robots(custom_name = _); end
-  def nofollow?(custom_name = _); end
-  def noindex?(custom_name = _); end
-  def serialize(options = _); end
+  def meta_robots(custom_name = T.unsafe(nil)); end
+  def nofollow?(custom_name = T.unsafe(nil)); end
+  def noindex?(custom_name = T.unsafe(nil)); end
+  def serialize(options = T.unsafe(nil)); end
   def title; end
   def title=(text); end
   def type; end
@@ -21,14 +22,16 @@ class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
   def parse_meta_robots(custom_name); end
   def set_metadata_element(element); end
 
-  def self.new(*_); end
-  def self.parse(string_or_io, url = _, encoding = _, options = _); end
-  def self.read_io(_, _, _, _); end
-  def self.read_memory(_, _, _, _); end
+  class << self
+    def new(*_); end
+    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    def read_io(_, _, _, _); end
+    def read_memory(_, _, _, _); end
+  end
 end
 
 class WebRobots
-  def initialize(user_agent, options = _); end
+  def initialize(user_agent, options = T.unsafe(nil)); end
 
   def allowed?(url); end
   def crawl_delay(url); end
@@ -64,24 +67,26 @@ class WebRobots::ParseError < ::WebRobots::Error
 end
 
 class WebRobots::RobotsTxt
-  def initialize(site, records, options = _); end
+  def initialize(site, records, options = T.unsafe(nil)); end
 
-  def allow?(request_uri, user_agent = _); end
-  def crawl_delay(user_agent = _); end
+  def allow?(request_uri, user_agent = T.unsafe(nil)); end
+  def crawl_delay(user_agent = T.unsafe(nil)); end
   def error; end
   def error!; end
   def error=(_); end
-  def options(user_agent = _); end
+  def options(user_agent = T.unsafe(nil)); end
   def site; end
   def sitemaps; end
   def timestamp; end
 
   private
 
-  def find_record(user_agent = _); end
-  def target(user_agent = _); end
+  def find_record(user_agent = T.unsafe(nil)); end
+  def target(user_agent = T.unsafe(nil)); end
 
-  def self.unfetchable(site, reason, target = _); end
+  class << self
+    def unfetchable(site, reason, target = T.unsafe(nil)); end
+  end
 end
 
 class WebRobots::RobotsTxt::AccessControlLine < ::WebRobots::RobotsTxt::Line
@@ -121,7 +126,7 @@ class WebRobots::RobotsTxt::Line
 end
 
 class WebRobots::RobotsTxt::Parser < ::Racc::Parser
-  def initialize(target, crawl_delay_handler = _); end
+  def initialize(target, crawl_delay_handler = T.unsafe(nil)); end
 
   def _reduce_1(val, _values, result); end
   def _reduce_17(val, _values, result); end
diff --git a/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.4.0.rbi
index 198c6b42fc..78c0137b3e 100644
--- a/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.4.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.4.0.rbi
@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync --exclude json
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `zeitwerk` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index 010474a7cb..ca6c39655c 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -5496,6 +5496,8 @@ class Cask::Cask
 
   def depends_on(&block); end
 
+  def desc(&block); end
+
   def dictionary(&block); end
 
   def font(&block); end
@@ -8090,6 +8092,10 @@ module Homebrew
   MIN_PORT = ::T.let(nil, ::T.untyped)
 end
 
+class Homebrew::CLI::Parser
+  include ::Homebrew::CLI::Parser::Compat
+end
+
 module Homebrew::EnvConfig
   def self.all_proxy(); end
 
@@ -13370,6 +13376,7 @@ class Object
   def to_yaml(options=T.unsafe(nil)); end
   ARGF = ::T.let(nil, ::T.untyped)
   ARGV = ::T.let(nil, ::T.untyped)
+  BUG_REPORTS_URL = ::T.let(nil, ::T.untyped)
   CROSS_COMPILING = ::T.let(nil, ::T.untyped)
   DEPRECATED_OFFICIAL_TAPS = ::T.let(nil, ::T.untyped)
   ENV = ::T.let(nil, ::T.untyped)
@@ -19536,6 +19543,8 @@ class RuboCop::Cask::AST::Stanza
 
   def depends_on?(); end
 
+  def desc?(); end
+
   def dictionary?(); end
 
   def font?(); end
@@ -19613,6 +19622,10 @@ class RuboCop::Cop::Cask::NoDslVersion
   def preferred_header_str(*args, &block); end
 end
 
+module RuboCop::Cop::Cask::OnDescStanza
+  def toplevel_stanzas(*args, &block); end
+end
+
 module RuboCop::Cop::Cask::OnHomepageStanza
   def toplevel_stanzas(*args, &block); end
 end
@@ -21064,6 +21077,7 @@ class SimpleCov::Formatter::Codecov
   CIRCLE = ::T.let(nil, ::T.untyped)
   CODESHIP = ::T.let(nil, ::T.untyped)
   DRONEIO = ::T.let(nil, ::T.untyped)
+  GITHUB = ::T.let(nil, ::T.untyped)
   GITLAB = ::T.let(nil, ::T.untyped)
   HEROKU = ::T.let(nil, ::T.untyped)
   JENKINS = ::T.let(nil, ::T.untyped)
@@ -21995,8 +22009,6 @@ class SystemCommand
   def print_stdout?(); end
 
   def sudo?(); end
-
-  def verbose?(); end
 end
 
 module TZInfo
@@ -22973,42 +22985,6 @@ end
 class Tempfile::Remover
 end
 
-class Thor::Group
-  def self.banner(); end
-
-  def self.self_command(); end
-
-  def self.self_task(); end
-end
-
-class Thor
-  def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
-
-  def self.disable_required_check(); end
-
-  def self.dispatch(meth, given_args, given_opts, config); end
-
-  def self.dynamic_command_class(); end
-
-  def self.find_command_possibilities(meth); end
-
-  def self.find_task_possibilities(meth); end
-
-  def self.normalize_command_name(meth); end
-
-  def self.normalize_task_name(meth); end
-
-  def self.retrieve_command_name(args); end
-
-  def self.retrieve_task_name(args); end
-
-  def self.stop_on_unknown_option(); end
-
-  def self.subcommand_help(cmd); end
-
-  def self.subtask_help(cmd); end
-end
-
 module ThreadSafe
   NULL = ::T.let(nil, ::T.untyped)
   VERSION = ::T.let(nil, ::T.untyped)