diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock
index edbc6878cb..6665cce0a2 100644
--- a/Library/Homebrew/Gemfile.lock
+++ b/Library/Homebrew/Gemfile.lock
@@ -61,7 +61,7 @@ GEM
     parallel (1.20.1)
     parallel_tests (3.7.0)
       parallel
-    parlour (6.0.0)
+    parlour (6.0.1)
       commander (~> 4.5)
       parser
       rainbow (~> 3.0)
diff --git a/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi
similarity index 93%
rename from Library/Homebrew/sorbet/rbi/gems/parlour@6.0.0.rbi
rename to Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi
index 52fa968137..ef05efa111 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi
@@ -1,12 +1,44 @@
 # 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`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module Parlour
+class AST::Node
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  def +(array); end
+  def <<(element); end
+  def ==(other); end
+  def append(element); end
+  def children; end
+  def clone; end
+  def concat(array); end
+  def deconstruct; end
+  def dup; end
+  def eql?(other); end
+  def hash; end
+  def inspect(indent = T.unsafe(nil)); end
+  def to_a; end
+  def to_ast; 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 = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  protected
+
+  def assign_properties(properties); end
+  def fancy_type; end
+
+  private
+
+  def original_dup; end
 end
 
+module Parlour; end
+
 class Parlour::ConflictResolver
   sig { params(namespace: Parlour::RbiGenerator::Namespace, resolver: T.proc.params(desc: String, choices: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T.nilable(Parlour::RbiGenerator::RbiObject))).void }
   def resolve_conflicts(namespace, &resolver); end
@@ -15,14 +47,15 @@ class Parlour::ConflictResolver
 
   sig { params(arr: T::Array[T.untyped]).returns(T::Boolean) }
   def all_eql?(arr); end
+
   sig { params(namespace: Parlour::RbiGenerator::Namespace, name: T.nilable(String)).void }
   def deduplicate_mixins_of_name(namespace, name); end
+
   sig { params(arr: T::Array[T.untyped]).returns(T.nilable(Symbol)) }
   def merge_strategy(arr); end
 end
 
-module Parlour::Conversion
-end
+module Parlour::Conversion; end
 
 class Parlour::Conversion::Converter
   abstract!
@@ -31,6 +64,7 @@ class Parlour::Conversion::Converter
 
   sig { params(msg: String, node: Parlour::RbiGenerator::RbiObject).void }
   def add_warning(msg, node); end
+
   sig { returns(T::Array[[String, Parlour::TypedObject]]) }
   def warnings; end
 end
@@ -41,8 +75,10 @@ class Parlour::Conversion::RbiToRbs < ::Parlour::Conversion::Converter
 
   sig { params(from: Parlour::RbiGenerator::Namespace, to: Parlour::RbsGenerator::Namespace).void }
   def convert_all(from, to); end
+
   sig { params(node: Parlour::RbiGenerator::RbiObject, new_parent: Parlour::RbsGenerator::Namespace).void }
   def convert_object(node, new_parent); end
+
   sig { returns(Parlour::RbsGenerator) }
   def rbs_gen; end
 end
@@ -51,10 +87,13 @@ module Parlour::Debugging
   class << self
     sig { params(value: T::Boolean).returns(T::Boolean) }
     def debug_mode=(value); end
+
     sig { returns(T::Boolean) }
     def debug_mode?; end
+
     sig { params(object: T.untyped, message: String).void }
     def debug_puts(object, message); end
+
     sig { params(object: T.untyped).returns(String) }
     def name_for_debug_caller(object); end
   end
@@ -64,10 +103,13 @@ module Parlour::Debugging::Tree
   class << self
     sig { params(message: String).returns(String) }
     def begin(message); end
+
     sig { params(message: String).returns(String) }
     def end(message); end
+
     sig { params(message: String).returns(String) }
     def here(message); end
+
     def line_prefix; end
     def text_prefix; end
   end
@@ -78,10 +120,13 @@ Parlour::Debugging::Tree::INDENT_SPACES = T.let(T.unsafe(nil), Integer)
 class Parlour::DetachedRbiGenerator < ::Parlour::RbiGenerator
   sig { override.returns(T.nilable(Parlour::Plugin)) }
   def current_plugin; end
+
   sig { returns(T.untyped) }
   def detached!; end
+
   sig { override.returns(Parlour::Options) }
   def options; end
+
   sig { override.params(strictness: String).returns(String) }
   def rbi(strictness = T.unsafe(nil)); end
 end
@@ -89,10 +134,13 @@ end
 class Parlour::DetachedRbsGenerator < ::Parlour::RbsGenerator
   sig { override.returns(T.nilable(Parlour::Plugin)) }
   def current_plugin; end
+
   sig { returns(T.untyped) }
   def detached!; end
+
   sig { override.returns(Parlour::Options) }
   def options; end
+
   sig { override.returns(String) }
   def rbs; end
 end
@@ -103,7 +151,9 @@ class Parlour::Generator
 
   sig { overridable.returns(T.nilable(Parlour::Plugin)) }
   def current_plugin; end
+
   def current_plugin=(_arg0); end
+
   sig { overridable.returns(Parlour::Options) }
   def options; end
 end
@@ -114,10 +164,13 @@ class Parlour::Options
 
   sig { returns(Integer) }
   def break_params; end
+
   sig { params(level: Integer, str: String).returns(String) }
   def indented(level, str); end
+
   sig { returns(T::Boolean) }
   def sort_namespaces; end
+
   sig { returns(Integer) }
   def tab_size; end
 end
@@ -127,6 +180,7 @@ class Parlour::ParseError < ::StandardError
 
   sig { returns(Parser::Source::Buffer) }
   def buffer; end
+
   sig { returns(Parser::Source::Range) }
   def range; end
 end
@@ -139,15 +193,19 @@ class Parlour::Plugin
 
   sig { abstract.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root); end
+
   sig { returns(T.nilable(String)) }
   def strictness; end
+
   def strictness=(_arg0); end
 
   class << self
     sig { params(new_plugin: T.class_of(Parlour::Plugin)).void }
     def inherited(new_plugin); end
+
     sig { returns(T::Hash[String, T.class_of(Parlour::Plugin)]) }
     def registered_plugins; end
+
     sig { params(plugins: T::Array[Parlour::Plugin], generator: Parlour::RbiGenerator, allow_failure: T::Boolean).void }
     def run_plugins(plugins, generator, allow_failure: T.unsafe(nil)); end
   end
@@ -158,6 +216,7 @@ class Parlour::RbiGenerator < ::Parlour::Generator
 
   sig { overridable.params(strictness: String).returns(String) }
   def rbi(strictness = T.unsafe(nil)); end
+
   sig { overridable.returns(Parlour::RbiGenerator::Namespace) }
   def root; end
 end
@@ -168,17 +227,24 @@ class Parlour::RbiGenerator::Arbitrary < ::Parlour::RbiGenerator::RbiObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(String) }
   def code; end
+
   def code=(_arg0); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
 end
@@ -189,12 +255,16 @@ class Parlour::RbiGenerator::Attribute < ::Parlour::RbiGenerator::Method
 
   sig { override.params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(T::Boolean) }
   def class_attribute; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { returns(Symbol) }
   def kind; end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 
@@ -210,16 +280,22 @@ class Parlour::RbiGenerator::ClassNamespace < ::Parlour::RbiGenerator::Namespace
 
   sig { returns(T::Boolean) }
   def abstract; end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T.nilable(String)) }
   def superclass; end
 end
@@ -230,17 +306,24 @@ class Parlour::RbiGenerator::Constant < ::Parlour::RbiGenerator::RbiObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   def eigen_constant; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def value; end
 end
@@ -251,12 +334,16 @@ class Parlour::RbiGenerator::EnumClassNamespace < ::Parlour::RbiGenerator::Class
 
   sig { returns(T::Array[T.any(String, [String, String])]) }
   def enums; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_body(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
 end
@@ -267,14 +354,19 @@ class Parlour::RbiGenerator::Extend < ::Parlour::RbiGenerator::RbiObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
 end
@@ -285,14 +377,19 @@ class Parlour::RbiGenerator::Include < ::Parlour::RbiGenerator::RbiObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
 end
@@ -303,32 +400,46 @@ class Parlour::RbiGenerator::Method < ::Parlour::RbiGenerator::RbiObject
 
   sig { overridable.params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(T::Boolean) }
   def abstract; end
+
   sig { returns(T::Boolean) }
   def class_method; end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { returns(T::Boolean) }
   def final; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { returns(T::Boolean) }
   def implementation; end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T::Boolean) }
   def overridable; end
+
   sig { returns(T::Boolean) }
   def override; end
+
   sig { returns(T::Array[Parlour::RbiGenerator::Parameter]) }
   def parameters; end
+
   sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) }
   def return_type; end
+
   sig { returns(T::Array[Symbol]) }
   def type_parameters; end
 
@@ -336,6 +447,7 @@ class Parlour::RbiGenerator::Method < ::Parlour::RbiGenerator::RbiObject
 
   sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_definition(indent_level, options); end
+
   sig { returns(String) }
   def qualifiers; end
 end
@@ -346,16 +458,22 @@ class Parlour::RbiGenerator::ModuleNamespace < ::Parlour::RbiGenerator::Namespac
 
   sig { returns(T::Boolean) }
   def abstract; end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { returns(T::Boolean) }
   def interface; end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
 end
@@ -366,70 +484,101 @@ class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject
 
   sig { params(comment: T.any(String, T::Array[String])).void }
   def add_comment_to_next_child(comment); end
+
   sig { returns(T::Array[Parlour::RbiGenerator::TypeAlias]) }
   def aliases; end
+
   sig { returns(T::Array[Parlour::RbiGenerator::RbiObject]) }
   def children; end
+
   sig { returns(T::Array[Parlour::RbiGenerator::Constant]) }
   def constants; end
+
   def create_arbitrary(code:, &block); end
   def create_attr(*args, &blk); end
+
   sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
   def create_attr_accessor(name, type:, class_attribute: T.unsafe(nil), &block); end
+
   sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
   def create_attr_reader(name, type:, class_attribute: T.unsafe(nil), &block); end
+
   sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
   def create_attr_writer(name, type:, class_attribute: T.unsafe(nil), &block); end
+
   sig { params(name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
   def create_attribute(name, kind:, type:, class_attribute: T.unsafe(nil), &block); end
+
   sig { params(name: String, final: T::Boolean, sealed: T::Boolean, superclass: T.nilable(String), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ClassNamespace) }
   def create_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), superclass: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
   sig { params(name: String, value: String, eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Constant).void)).returns(Parlour::RbiGenerator::Constant) }
   def create_constant(name, value:, eigen_constant: T.unsafe(nil), &block); end
+
   sig { params(name: String, final: T::Boolean, sealed: T::Boolean, enums: T.nilable(T::Array[T.any(String, [String, String])]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)).returns(Parlour::RbiGenerator::EnumClassNamespace) }
   def create_enum_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), enums: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
   sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Extend).void)).returns(Parlour::RbiGenerator::Extend) }
   def create_extend(name, &block); end
+
   sig { params(extendables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Extend]) }
   def create_extends(extendables); end
+
   sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Include).void)).returns(Parlour::RbiGenerator::Include) }
   def create_include(name, &block); end
+
   sig { params(includables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Include]) }
   def create_includes(includables); end
+
   sig { params(name: String, parameters: T.nilable(T::Array[Parlour::RbiGenerator::Parameter]), return_type: T.nilable(T.any(Parlour::Types::Type, String)), returns: T.nilable(T.any(Parlour::Types::Type, String)), abstract: T::Boolean, implementation: T::Boolean, override: T::Boolean, overridable: T::Boolean, class_method: T::Boolean, final: T::Boolean, type_parameters: T.nilable(T::Array[Symbol]), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Method).void)).returns(Parlour::RbiGenerator::Method) }
   def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), returns: T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
+
   sig { params(name: String, final: T::Boolean, sealed: T::Boolean, interface: T::Boolean, abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ModuleNamespace) }
   def create_module(name, final: T.unsafe(nil), sealed: T.unsafe(nil), interface: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
   sig { params(name: String, final: T::Boolean, sealed: T::Boolean, props: T.nilable(T::Array[Parlour::RbiGenerator::StructProp]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)).returns(Parlour::RbiGenerator::StructClassNamespace) }
   def create_struct_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), props: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
   sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::TypeAlias).void)).returns(Parlour::RbiGenerator::TypeAlias) }
   def create_type_alias(name, type:, &block); end
-  sig { overridable.override.returns(String) }
+
+  sig { override.overridable.returns(String) }
   def describe; end
+
   sig { returns(T::Array[Parlour::RbiGenerator::Extend]) }
   def extends; end
+
   sig { returns(T::Boolean) }
   def final; end
+
   sig { override.void }
   def generalize_from_rbi!; end
-  sig { overridable.override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+
+  sig { override.overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { returns(T::Array[Parlour::RbiGenerator::Include]) }
   def includes; end
-  sig { overridable.override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+
+  sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
-  sig { overridable.override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+
+  sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { params(constant: Module, block: T.proc.params(x: Parlour::RbiGenerator::Namespace).void).void }
   def path(constant, &block); end
+
   sig { returns(T::Boolean) }
   def sealed; end
+
   def type_aliases(*args, &blk); end
 
   private
 
   sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_body(indent_level, options); end
+
   sig { params(object: Parlour::RbiGenerator::RbiObject).void }
   def move_next_comments(object); end
 end
@@ -442,20 +591,28 @@ class Parlour::RbiGenerator::Parameter
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(T.nilable(String)) }
   def default; end
+
   sig { void }
   def generalize_from_rbi!; end
+
   sig { returns(Symbol) }
   def kind; end
+
   sig { returns(String) }
   def name; end
+
   sig { returns(String) }
   def name_without_kind; end
+
   sig { returns(String) }
   def to_def_param; end
+
   sig { returns(String) }
   def to_sig_param; end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 end
@@ -468,16 +625,21 @@ class Parlour::RbiGenerator::RbiObject < ::Parlour::TypedObject
   sig { params(generator: Parlour::Generator, name: String).void }
   def initialize(generator, name); end
 
-  sig { overridable.override.returns(String) }
+  sig { override.overridable.returns(String) }
   def describe; end
+
   sig { abstract.void }
   def generalize_from_rbi!; end
+
   sig { abstract.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { returns(Parlour::Generator) }
   def generator; end
+
   sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
 end
@@ -488,12 +650,16 @@ class Parlour::RbiGenerator::StructClassNamespace < ::Parlour::RbiGenerator::Cla
 
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_body(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T::Array[Parlour::RbiGenerator::StructProp]) }
   def props; end
 end
@@ -504,32 +670,46 @@ class Parlour::RbiGenerator::StructProp
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(T.nilable(String)) }
   def array; end
+
   sig { returns(T.nilable(String)) }
   def default; end
+
   sig { returns(T.nilable(T::Boolean)) }
   def dont_store; end
+
   sig { returns(T.nilable(String)) }
   def enum; end
+
   sig { returns(T.nilable(String)) }
   def factory; end
+
   sig { returns(T.nilable(String)) }
   def foreign; end
+
   sig { void }
   def generalize_from_rbi!; end
+
   sig { returns(T.nilable(T::Boolean)) }
   def immutable; end
+
   sig { returns(String) }
   def name; end
+
   sig { returns(T.nilable(T.any(Symbol, T::Boolean))) }
   def optional; end
+
   sig { returns(T.nilable(T::Boolean)) }
   def override; end
+
   sig { returns(T.nilable(String)) }
   def redaction; end
+
   sig { returns(String) }
   def to_prop_call; end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 end
@@ -542,16 +722,22 @@ class Parlour::RbiGenerator::TypeAlias < ::Parlour::RbiGenerator::RbiObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.void }
   def generalize_from_rbi!; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbi(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 end
@@ -561,6 +747,7 @@ class Parlour::RbsGenerator < ::Parlour::Generator
 
   sig { overridable.returns(String) }
   def rbs; end
+
   sig { overridable.returns(Parlour::RbsGenerator::Namespace) }
   def root; end
 end
@@ -571,15 +758,21 @@ class Parlour::RbsGenerator::Arbitrary < ::Parlour::RbsGenerator::RbsObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(String) }
   def code; end
+
   def code=(_arg0); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
   def mergeable?(others); end
 end
@@ -590,10 +783,13 @@ class Parlour::RbsGenerator::Attribute < ::Parlour::RbsGenerator::Method
 
   sig { override.params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { returns(Symbol) }
   def kind; end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 end
@@ -604,10 +800,13 @@ class Parlour::RbsGenerator::Block
 
   sig { overridable.params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { params(options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(options); end
+
   sig { returns(T::Boolean) }
   def required; end
+
   sig { returns(Parlour::Types::Proc) }
   def type; end
 end
@@ -618,12 +817,16 @@ class Parlour::RbsGenerator::ClassNamespace < ::Parlour::RbsGenerator::Namespace
 
   sig { override.returns(String) }
   def describe; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) }
   def superclass; end
 end
@@ -634,14 +837,19 @@ class Parlour::RbsGenerator::Constant < ::Parlour::RbsGenerator::RbsObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 end
@@ -652,14 +860,19 @@ class Parlour::RbsGenerator::Extend < ::Parlour::RbsGenerator::RbsObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 end
@@ -670,14 +883,19 @@ class Parlour::RbsGenerator::Include < ::Parlour::RbsGenerator::RbsObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 end
@@ -685,6 +903,7 @@ end
 class Parlour::RbsGenerator::InterfaceNamespace < ::Parlour::RbsGenerator::Namespace
   sig { override.returns(String) }
   def describe; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
 end
@@ -695,16 +914,22 @@ class Parlour::RbsGenerator::Method < ::Parlour::RbsGenerator::RbsObject
 
   sig { overridable.params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(T::Boolean) }
   def class_method; end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T::Array[Parlour::RbsGenerator::MethodSignature]) }
   def signatures; end
 end
@@ -715,14 +940,19 @@ class Parlour::RbsGenerator::MethodSignature
 
   sig { overridable.params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(T.nilable(Parlour::RbsGenerator::Block)) }
   def block; end
+
   sig { params(options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(options); end
+
   sig { returns(T::Array[Parlour::RbsGenerator::Parameter]) }
   def parameters; end
+
   sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) }
   def return_type; end
+
   sig { returns(T::Array[Symbol]) }
   def type_parameters; end
 end
@@ -730,6 +960,7 @@ end
 class Parlour::RbsGenerator::ModuleNamespace < ::Parlour::RbsGenerator::Namespace
   sig { override.returns(String) }
   def describe; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
 end
@@ -740,62 +971,89 @@ class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject
 
   sig { params(comment: T.any(String, T::Array[String])).void }
   def add_comment_to_next_child(comment); end
+
   sig { returns(T::Array[Parlour::RbsGenerator::TypeAlias]) }
   def aliases; end
+
   sig { returns(T::Array[Parlour::RbsGenerator::RbsObject]) }
   def children; end
+
   sig { returns(T::Array[Parlour::RbsGenerator::Constant]) }
   def constants; end
+
   def create_arbitrary(code:, &block); end
   def create_attr(*args, &blk); end
+
   sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) }
   def create_attr_accessor(name, type:, &block); end
+
   sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) }
   def create_attr_reader(name, type:, &block); end
+
   sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) }
   def create_attr_writer(name, type:, &block); end
+
   sig { params(name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) }
   def create_attribute(name, kind:, type:, &block); end
+
   sig { params(name: String, superclass: T.nilable(T.any(Parlour::Types::Type, String)), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void)).returns(Parlour::RbsGenerator::ClassNamespace) }
   def create_class(name, superclass: T.unsafe(nil), &block); end
+
   sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Constant).void)).returns(Parlour::RbsGenerator::Constant) }
   def create_constant(name, type:, &block); end
+
   sig { params(type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Extend).void)).returns(Parlour::RbsGenerator::Extend) }
   def create_extend(type, &block); end
+
   sig { params(extendables: T::Array[T.any(Parlour::Types::Type, String)]).returns(T::Array[Parlour::RbsGenerator::Extend]) }
   def create_extends(extendables); end
+
   sig { params(type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Include).void)).returns(Parlour::RbsGenerator::Include) }
   def create_include(type, &block); end
+
   sig { params(includables: T::Array[T.any(Parlour::Types::Type, String)]).returns(T::Array[Parlour::RbsGenerator::Include]) }
   def create_includes(includables); end
+
   sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)).returns(Parlour::RbsGenerator::InterfaceNamespace) }
   def create_interface(name, &block); end
+
   sig { params(name: String, signatures: T.nilable(T::Array[Parlour::RbsGenerator::MethodSignature]), class_method: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Method).void)).returns(Parlour::RbsGenerator::Method) }
   def create_method(name, signatures = T.unsafe(nil), class_method: T.unsafe(nil), &block); end
+
   sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)).returns(Parlour::RbsGenerator::ModuleNamespace) }
   def create_module(name, &block); end
+
   sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::TypeAlias).void)).returns(Parlour::RbsGenerator::TypeAlias) }
   def create_type_alias(name, type:, &block); end
-  sig { overridable.override.returns(String) }
+
+  sig { override.overridable.returns(String) }
   def describe; end
+
   sig { returns(T::Array[Parlour::RbsGenerator::Extend]) }
   def extends; end
-  sig { overridable.override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+
+  sig { override.overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { returns(T::Array[Parlour::RbsGenerator::Include]) }
   def includes; end
-  sig { overridable.override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
+
+  sig { override.overridable.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
   def merge_into_self(others); end
-  sig { overridable.override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+
+  sig { override.overridable.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { params(object: T.untyped, block: T.proc.params(x: Parlour::RbsGenerator::Namespace).void).void }
   def path(object, &block); end
+
   def type_aliases(*args, &blk); end
 
   private
 
   sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_body(indent_level, options); end
+
   sig { params(object: Parlour::RbsGenerator::RbsObject).void }
   def move_next_comments(object); end
 end
@@ -806,22 +1064,27 @@ class Parlour::RbsGenerator::Parameter
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(Symbol) }
   def kind; end
+
   sig { returns(String) }
   def name; end
+
   sig { returns(String) }
   def name_without_kind; end
+
   sig { returns(T::Boolean) }
   def required; end
+
   sig { returns(String) }
   def to_rbs_param; end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 end
 
 Parlour::RbsGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash)
-
 Parlour::RbsGenerator::Parameter::RBS_KEYWORDS = T.let(T.unsafe(nil), Array)
 
 class Parlour::RbsGenerator::RbsObject < ::Parlour::TypedObject
@@ -830,14 +1093,18 @@ class Parlour::RbsGenerator::RbsObject < ::Parlour::TypedObject
   sig { params(generator: Parlour::Generator, name: String).void }
   def initialize(generator, name); end
 
-  sig { overridable.override.returns(String) }
+  sig { override.overridable.returns(String) }
   def describe; end
+
   sig { abstract.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { returns(Parlour::Generator) }
   def generator; end
+
   sig { abstract.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
   def merge_into_self(others); end
+
   sig { abstract.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
   def mergeable?(others); end
 end
@@ -848,14 +1115,19 @@ class Parlour::RbsGenerator::TypeAlias < ::Parlour::RbsGenerator::RbsObject
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
   def generate_rbs(indent_level, options); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
   def merge_into_self(others); end
+
   sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
   def mergeable?(others); end
+
   sig { returns(T.any(Parlour::Types::Type, String)) }
   def type; end
 end
@@ -864,8 +1136,10 @@ module Parlour::TypeLoader
   class << self
     sig { params(filename: String, generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::RbiGenerator::Namespace) }
     def load_file(filename, generator: T.unsafe(nil)); end
+
     sig { params(root: String, inclusions: T::Array[String], exclusions: T::Array[String], generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::RbiGenerator::Namespace) }
     def load_project(root, inclusions: T.unsafe(nil), exclusions: T.unsafe(nil), generator: T.unsafe(nil)); end
+
     sig { params(source: String, filename: T.nilable(String), generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::RbiGenerator::Namespace) }
     def load_source(source, filename = T.unsafe(nil), generator: T.unsafe(nil)); end
   end
@@ -877,22 +1151,32 @@ class Parlour::TypeParser
 
   sig { returns(Parser::AST::Node) }
   def ast; end
+
   def ast=(_arg0); end
+
   sig { returns(Parlour::RbiGenerator) }
   def generator; end
+
   def generator=(_arg0); end
+
   sig { returns(Parlour::RbiGenerator::Namespace) }
   def parse_all; end
+
   sig { params(path: Parlour::TypeParser::NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[Parlour::RbiGenerator::Method]) }
   def parse_method_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end
+
   sig { params(node: Parser::AST::Node).returns(Parlour::Types::Type) }
   def parse_node_to_type(node); end
+
   sig { params(path: Parlour::TypeParser::NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[Parlour::RbiGenerator::RbiObject]) }
   def parse_path_to_object(path, is_within_eigenclass: T.unsafe(nil)); end
+
   sig { params(path: Parlour::TypeParser::NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[Parlour::RbiGenerator::Method]) }
   def parse_sig_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end
+
   sig { params(path: Parlour::TypeParser::NodePath).returns(Parlour::TypeParser::IntermediateSig) }
   def parse_sig_into_sig(path); end
+
   sig { returns(T::Boolean) }
   def unknown_node_errors; end
 
@@ -900,39 +1184,48 @@ class Parlour::TypeParser
 
   sig { params(node: T.nilable(Parser::AST::Node), modifier: Symbol).returns(T::Boolean) }
   def body_has_modifier?(node, modifier); end
+
   sig { params(node: Parser::AST::Node).returns([T::Array[String], T::Array[String]]) }
   def body_includes_and_extends(node); end
+
   sig { params(node: T.nilable(Parser::AST::Node)).returns(T::Array[Symbol]) }
   def constant_names(node); end
+
   sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
   def node_to_s(node); end
+
   sig { params(desc: String, node: T.any(Parlour::TypeParser::NodePath, Parser::AST::Node)).returns(T.noreturn) }
   def parse_err(desc, node); end
+
   sig { params(path: Parlour::TypeParser::NodePath).returns(T::Boolean) }
   def previous_sibling_sig_node?(path); end
+
   sig { params(node: Parser::AST::Node).returns(T::Boolean) }
   def sig_node?(node); end
+
   sig { params(msg: String, node: Parser::AST::Node).void }
   def warning(msg, node); end
+
   sig { type_parameters(:A, :B).params(a: T::Array[T.type_parameter(:A)], fa: T.proc.params(item: T.type_parameter(:A)).returns(T.untyped), b: T::Array[T.type_parameter(:B)], fb: T.proc.params(item: T.type_parameter(:B)).returns(T.untyped)).returns(T::Array[[T.type_parameter(:A), T.type_parameter(:B)]]) }
   def zip_by(a, fa, b, fb); end
 
   class << self
     sig { params(filename: String, source: String, generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::TypeParser) }
     def from_source(filename, source, generator: T.unsafe(nil)); end
+
     sig { params(str: String).returns(Parlour::Types::Type) }
     def parse_single_type(str); end
   end
 end
 
 class Parlour::TypeParser::IntermediateSig < ::T::Struct
-  prop :type_parameters, T.nilable(T::Array[Symbol])
-  prop :overridable, T::Boolean
-  prop :override, T::Boolean
   prop :abstract, T::Boolean
   prop :final, T::Boolean
-  prop :return_type, T.nilable(String)
+  prop :overridable, T::Boolean
+  prop :override, T::Boolean
   prop :params, T.nilable(T::Array[Parser::AST::Node])
+  prop :return_type, T.nilable(String)
+  prop :type_parameters, T.nilable(T::Array[Symbol])
 
   class << self
     def inherited(s); end
@@ -945,12 +1238,16 @@ class Parlour::TypeParser::NodePath
 
   sig { params(index: Integer).returns(Parlour::TypeParser::NodePath) }
   def child(index); end
+
   sig { returns(T::Array[Integer]) }
   def indices; end
+
   sig { returns(Parlour::TypeParser::NodePath) }
   def parent; end
+
   sig { params(offset: Integer).returns(Parlour::TypeParser::NodePath) }
   def sibling(offset); end
+
   sig { params(start: Parser::AST::Node).returns(Parser::AST::Node) }
   def traverse(start); end
 end
@@ -963,13 +1260,18 @@ class Parlour::TypedObject
 
   sig { params(comment: T.any(String, T::Array[String])).void }
   def add_comment(comment); end
+
   def add_comments(*args, &blk); end
+
   sig { returns(T::Array[String]) }
   def comments; end
+
   sig { abstract.returns(String) }
   def describe; end
+
   sig { returns(T.nilable(Parlour::Plugin)) }
   def generated_by; end
+
   sig { returns(String) }
   def name; end
 
@@ -979,12 +1281,12 @@ class Parlour::TypedObject
   def generate_comments(indent_level, options); end
 end
 
-module Parlour::Types
-end
+module Parlour::Types; end
 
 class Parlour::Types::Array < ::Parlour::Types::SingleElementCollection
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def collection_name; end
 end
@@ -992,10 +1294,13 @@ end
 class Parlour::Types::Boolean < ::Parlour::Types::Type
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
 end
@@ -1006,12 +1311,16 @@ class Parlour::Types::Class < ::Parlour::Types::Type
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(Parlour::Types::Type) }
   def type; end
 end
@@ -1019,6 +1328,7 @@ end
 class Parlour::Types::Enumerable < ::Parlour::Types::SingleElementCollection
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def collection_name; end
 end
@@ -1026,6 +1336,7 @@ end
 class Parlour::Types::Enumerator < ::Parlour::Types::SingleElementCollection
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def collection_name; end
 end
@@ -1036,14 +1347,19 @@ class Parlour::Types::Generic < ::Parlour::Types::Type
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(Parlour::Types::Type) }
   def type; end
+
   sig { returns(T::Array[Parlour::Types::Type]) }
   def type_params; end
 end
@@ -1054,14 +1370,19 @@ class Parlour::Types::Hash < ::Parlour::Types::Type
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(Parlour::Types::Type) }
   def key; end
+
   sig { returns(Parlour::Types::Type) }
   def value; end
 end
@@ -1072,12 +1393,16 @@ class Parlour::Types::Intersection < ::Parlour::Types::Type
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(T::Array[Parlour::Types::Type]) }
   def types; end
 end
@@ -1088,12 +1413,16 @@ class Parlour::Types::Nilable < ::Parlour::Types::Type
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(Parlour::Types::Type) }
   def type; end
 end
@@ -1104,14 +1433,19 @@ class Parlour::Types::Proc < ::Parlour::Types::Type
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(T::Array[Parlour::Types::Proc::Parameter]) }
   def parameters; end
+
   sig { returns(T.nilable(Parlour::Types::Type)) }
   def return_type; end
 end
@@ -1122,10 +1456,13 @@ class Parlour::Types::Proc::Parameter
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { returns(T.nilable(String)) }
   def default; end
+
   sig { returns(String) }
   def name; end
+
   sig { returns(Parlour::Types::Type) }
   def type; end
 end
@@ -1133,6 +1470,7 @@ end
 class Parlour::Types::Range < ::Parlour::Types::SingleElementCollection
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def collection_name; end
 end
@@ -1143,12 +1481,16 @@ class Parlour::Types::Raw < ::Parlour::Types::Type
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(String) }
   def str; end
 end
@@ -1159,12 +1501,16 @@ class Parlour::Types::Record < ::Parlour::Types::Type
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(T::Hash[Symbol, Parlour::Types::Type]) }
   def keys_to_types; end
 end
@@ -1172,10 +1518,13 @@ end
 class Parlour::Types::Self < ::Parlour::Types::Type
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
 end
@@ -1183,6 +1532,7 @@ end
 class Parlour::Types::Set < ::Parlour::Types::SingleElementCollection
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def collection_name; end
 end
@@ -1195,12 +1545,16 @@ class Parlour::Types::SingleElementCollection < ::Parlour::Types::Type
 
   sig { abstract.returns(String) }
   def collection_name; end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { returns(Parlour::Types::Type) }
   def element; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
 end
@@ -1211,12 +1565,16 @@ class Parlour::Types::Tuple < ::Parlour::Types::Type
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(T::Array[Parlour::Types::Type]) }
   def types; end
 end
@@ -1228,11 +1586,15 @@ class Parlour::Types::Type
 
   sig { abstract.returns(String) }
   def describe; end
+
   sig { abstract.returns(String) }
   def generate_rbi; end
+
   sig { abstract.returns(String) }
   def generate_rbs; end
+
   def hash; end
+
   sig { params(type_like: T.any(Parlour::Types::Type, String)).returns(Parlour::Types::Type) }
   def to_type(type_like); end
 
@@ -1242,18 +1604,24 @@ class Parlour::Types::Type
   end
 end
 
+Parlour::Types::TypeLike = T.type_alias { T.any(Parlour::Types::Type, String) }
+
 class Parlour::Types::Union < ::Parlour::Types::Type
   sig { params(types: T::Array[T.any(Parlour::Types::Type, String)]).void }
   def initialize(types); end
 
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
+
   sig { returns(T::Array[Parlour::Types::Type]) }
   def types; end
 end
@@ -1261,12 +1629,98 @@ end
 class Parlour::Types::Untyped < ::Parlour::Types::Type
   sig { params(other: Object).returns(T::Boolean) }
   def ==(other); end
+
   sig { override.returns(String) }
   def describe; end
+
   sig { override.returns(String) }
   def generate_rbi; end
+
   sig { override.returns(String) }
   def generate_rbs; end
 end
 
 Parlour::VERSION = T.let(T.unsafe(nil), String)
+
+class Parser::AST::Node < ::AST::Node
+  def assign_properties(properties); end
+  def loc; end
+  def location; end
+end
+
+class Parser::Source::Buffer
+  def initialize(name, first_line = T.unsafe(nil), source: T.unsafe(nil)); end
+
+  def column_for_position(position); end
+  def decompose_position(position); end
+  def first_line; end
+  def freeze; end
+  def inspect; end
+  def last_line; end
+  def line_for_position(position); end
+  def line_range(lineno); end
+  def name; end
+  def raw_source=(input); end
+  def read; end
+  def slice(range); end
+  def source; end
+  def source=(input); end
+  def source_line(lineno); end
+  def source_lines; end
+  def source_range; end
+
+  private
+
+  def bsearch(line_begins, position); end
+  def line_begins; end
+  def line_index_for_position(position); 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)
+
+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: T.unsafe(nil), end_pos: T.unsafe(nil)); end
+  def begin; end
+  def begin_pos; end
+  def column; end
+  def column_range; end
+  def contained?(other); end
+  def contains?(other); end
+  def crossing?(other); end
+  def disjoint?(other); end
+  def empty?; end
+  def end; end
+  def end_pos; end
+  def eql?(_arg0); end
+  def first_line; end
+  def hash; end
+  def inspect; end
+  def intersect(other); end
+  def is?(*what); end
+  def join(other); end
+  def last_column; end
+  def last_line; end
+  def length; end
+  def line; end
+  def overlaps?(other); end
+  def resize(new_size); end
+  def size; end
+  def source; end
+  def source_buffer; end
+  def source_line; end
+  def to_a; end
+  def to_range; end
+  def to_s; end
+  def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index 04d4cefceb..2327fc4190 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -13162,10 +13162,6 @@ class Parlour::TypedObject
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-module Parlour::Types
-  TypeLike = ::T.let(nil, ::T.untyped)
-end
-
 class Parlour::Types::Proc::Parameter
   extend ::T::Sig
   extend ::T::Private::Methods::MethodHooks
diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb
index 5505d3edd4..144ba8a5f9 100644
--- a/Library/Homebrew/vendor/bundle/bundler/setup.rb
+++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb
@@ -55,7 +55,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel_tests-3.7.0/
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parser-3.0.1.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rainbow-3.0.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.6274/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parlour-6.0.0/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parlour-6.0.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/patchelf-1.3.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/plist-3.6.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/pry-0.14.1/lib"