parlour 5.0.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb1e682fc74b2ccd30ac9055caf652889e898e2632347bf6cf0898f218bd5562
-  data.tar.gz: fcca5ca04676cbeed657add051e344fd9b5fa0a7efc757339847310300aa4d42
+  metadata.gz: 1fd931ae39df4abe6c2080d7730f5ae9761f934e31632f0bade970a08f40e291
+  data.tar.gz: b1c626e9baef6177c35e0512807f08dd7d80bca7ffb0730529fdc8c4bd8923c3
 SHA512:
-  metadata.gz: cef41723b922734b49f8377dc3b5c60cf0071d2a9723326299872fea4789f8e6ea1cb280fcd21161d48bd5dbb074b416e60668138116e56caf1c8334cce8e535
-  data.tar.gz: b9ea0db060c8789e1324460cde4a69b1c20b829920e660024f53834e48cef536b5423736e6fce4859c2e2fea5339e3f26bdd7513947bafcc82bd239db57cc68a
+  metadata.gz: dafd27bee77f5cf8c86c1057b19a4ef3d62abcfd21ea79c8f914629cb857216345ec70cfe5919a1897c98426e30d180b06d5610a1295e190a81d5405cf648b44
+  data.tar.gz: b825ea72df23f2bf0e3e5aa406f1e5f5e9890ec52ddba815e3bebcafda52edc6f85590827f7d097fdb1897b57ef4b9ad4b0adec387e02525977a8d22d391467a

data/.github/workflows/ruby.yml

@@ -0,0 +1,46 @@
+name: Run tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        ruby: [2.4, 2.5, 2.6, 2.7, 3.0]
+    continue-on-error: false
+      
+    runs-on: ubuntu-latest    
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: bundle exec rake
+    - name: Check RBI is up-to-date
+      run: ./ci/check_rbi.sh
+
+  # Deploy documentation to GitHub Pages, if this is a push to master and the tests passed
+  deploy-docs:
+    if: ${{ github.ref == 'refs/heads/master' }}
+    
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 2.7
+    - name: Install dependencies
+      run: bundle install
+    - name: Build documentation
+      run: bundle exec yard
+    - name: Deploy to GitHub Actions
+      uses: JamesIves/github-pages-deploy-action@3.7.1
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        branch: gh-pages
+        folder: doc

data/CHANGELOG.md

@@ -3,6 +3,16 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [6.0.0] - 2021-02-28
+### Changed
+- The RBI previously included with the Parlour gem has been removed,
+  as it was causing issues with Sorbet. **If you were relying on Parlour's
+  bundled RBI while type-checking your project, you will now need to use the
+  RBI from sorbet-typed or the Parlour repo.**
+- `Namespace#path` will now work much more reliably for classes and
+  modules which replace methods from `Module` and `Class`, such as
+  `#name`.
+
 ## [5.0.0] - 2020-12-26
 ### Added
 - Added RBS generation support! This includes:

data/lib/parlour/rbi_generator/namespace.rb

@@ -106,28 +106,31 @@ module Parlour
         )
       end
 
-      sig { params(object: T.untyped, block: T.proc.params(x: Namespace).void).void }
-      # Given a Class or Module object, generates all classes and modules in the
-      # path to that object, then executes the given block on the last
-      # {Namespace}. This should only be executed on the root namespace.
-      # @param [Class, Module] object
+      sig { params(constant: Module, block: T.proc.params(x: Namespace).void).void }
+      # Given a constant (i.e. a Module instance), generates all classes
+      # and modules in the path to that object, then executes the given
+      # block on the last {Namespace}. This should only be executed on
+      # the root namespace.
+      # @param [Module] constant
       # @param block A block which the new {Namespace} yields itself to.
-      def path(object, &block)
+      def path(constant, &block)
         raise 'only call #path on root' if is_a?(ClassNamespace) || is_a?(ModuleNamespace)
 
-        parts = object.to_s.split('::')
-        parts_with_types = parts.size.times.map do |i|
-          [parts[i], Module.const_get(parts[0..i].join('::')).class]
-        end
+        constant_name = T.let(Module.instance_method(:name).bind(constant).call, T.nilable(String))
+        raise 'given constant does not have a name' unless constant_name
 
         current_part = self
-        parts_with_types.each do |(name, type)|
-          if type == Class
+        constant_name.split('::').each_with_object([]) do |name, namespace|
+          namespace << name
+          instance = Module.const_get(namespace.join("::"))
+
+          case instance
+          when Class
             current_part = current_part.create_class(name)
-          elsif type == Module
+          when Module
             current_part = current_part.create_module(name)
           else
-            raise "unexpected type: path part #{name} is a #{type}"
+            raise "unexpected type: path part #{name} is a #{instance.class}"
           end
         end
 

data/lib/parlour/version.rb

@@ -1,5 +1,5 @@
 # typed: strong
 module Parlour
   # The library version.
-  VERSION = '5.0.0'
+  VERSION = '6.0.0'
 end

data/parlour.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|sorbet)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|sorbet|rbi)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -32,4 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "sorbet"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "yard"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parlour
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-26 00:00:00.000000000 Z
+date: 2021-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -136,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 - hello@aaronc.cc
@@ -146,10 +160,10 @@ extra_rdoc_files: []
 files:
 - ".github/ISSUE_TEMPLATE/bug-report.md"
 - ".github/ISSUE_TEMPLATE/feature-request.md"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".parlour"
 - ".rspec"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -209,7 +223,6 @@ files:
 - lib/parlour/version.rb
 - parlour.gemspec
 - plugin_examples/foobar_plugin.rb
-- rbi/parlour.rbi
 homepage: https://github.com/AaronC81/parlour
 licenses:
 - MIT
@@ -229,7 +242,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.0.rc.1
 signing_key:
 specification_version: 4
 summary: A type information generator, merger and parser for Sorbet and Ruby 3/Steep

data/.travis.yml

@@ -1,32 +0,0 @@
-language: ruby
-dist: trusty
-before_install:
-  - gem install bundler
-  - gem install yard
-  - chmod +x ci/check_rbi.sh
-rvm: 
-  - 2.3
-  - 2.4
-  - 2.5
-  - 2.6
-  - 2.7
-  - ruby-head
-
-jobs:
-  include:
-    - stage: check RBI
-      script: ./ci/check_rbi.sh
-      rvm: 2.7
-    - stage: deploy documentation
-      script: yard
-      deploy:
-        provider: pages
-        local_dir: doc
-        skip_cleanup: true
-        github_token: $GITHUB_TOKEN
-        keep_history: true
-        on:
-          branch: master
-  allow_failures:
-    - rvm: 2.3
-    - rvm: ruby-head

data/rbi/parlour.rbi

@@ -1,1896 +0,0 @@
-# typed: strong
-module Kernel
-end
-
-module Parlour
-  VERSION = '5.0.0'
-
-  class ConflictResolver
-    extend T::Sig
-
-    sig { params(namespace: RbiGenerator::Namespace, resolver: T.proc.params(
-          desc: String,
-          choices: T::Array[RbiGenerator::RbiObject]
-        ).returns(T.nilable(RbiGenerator::RbiObject))).void }
-    def resolve_conflicts(namespace, &resolver); end
-
-    sig { params(arr: T::Array[T.untyped]).returns(T.nilable(Symbol)) }
-    def merge_strategy(arr); end
-
-    sig { params(arr: T::Array[T.untyped]).returns(T::Boolean) }
-    def all_eql?(arr); end
-
-    sig { params(namespace: RbiGenerator::Namespace, name: T.nilable(String)).void }
-    def deduplicate_mixins_of_name(namespace, name); end
-  end
-
-  module Debugging
-    extend T::Sig
-
-    sig { params(value: T::Boolean).returns(T::Boolean) }
-    def self.debug_mode=(value); end
-
-    sig { returns(T::Boolean) }
-    def self.debug_mode?; end
-
-    sig { params(object: T.untyped, message: String).void }
-    def self.debug_puts(object, message); end
-
-    sig { params(object: T.untyped).returns(String) }
-    def self.name_for_debug_caller(object); end
-
-    module Tree
-      extend T::Sig
-      INDENT_SPACES = 2
-
-      sig { params(message: String).returns(String) }
-      def self.begin(message); end
-
-      sig { params(message: String).returns(String) }
-      def self.here(message); end
-
-      sig { params(message: String).returns(String) }
-      def self.end(message); end
-
-      sig { returns(T.untyped) }
-      def self.line_prefix; end
-
-      sig { returns(T.untyped) }
-      def self.text_prefix; end
-    end
-  end
-
-  class DetachedRbsGenerator < RbsGenerator
-    sig { returns(T.untyped) }
-    def detached!; end
-
-    sig { override.returns(Options) }
-    def options; end
-
-    sig { override.returns(T.nilable(Plugin)) }
-    def current_plugin; end
-
-    sig { override.returns(String) }
-    def rbs; end
-  end
-
-  class Generator
-    extend T::Sig
-
-    sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
-    def initialize(break_params: 4, tab_size: 2, sort_namespaces: false); end
-
-    sig { returns(Options) }
-    attr_reader :options
-
-    sig { returns(T.nilable(Plugin)) }
-    attr_accessor :current_plugin
-  end
-
-  class Options
-    extend T::Sig
-
-    sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
-    def initialize(break_params:, tab_size:, sort_namespaces:); end
-
-    sig { returns(Integer) }
-    attr_reader :break_params
-
-    sig { returns(Integer) }
-    attr_reader :tab_size
-
-    sig { returns(T::Boolean) }
-    attr_reader :sort_namespaces
-
-    sig { params(level: Integer, str: String).returns(String) }
-    def indented(level, str); end
-  end
-
-  class ParseError < StandardError
-    extend T::Sig
-
-    sig { returns(Parser::Source::Buffer) }
-    attr_reader :buffer
-
-    sig { returns(Parser::Source::Range) }
-    attr_reader :range
-
-    sig { params(buffer: T.untyped, range: T.untyped).returns(T.untyped) }
-    def initialize(buffer, range); end
-  end
-
-  class Plugin
-    abstract!
-
-    extend T::Sig
-    extend T::Helpers
-
-    sig { returns(T::Hash[String, T.class_of(Plugin)]) }
-    def self.registered_plugins; end
-
-    sig { params(new_plugin: T.class_of(Plugin)).void }
-    def self.inherited(new_plugin); end
-
-    sig { params(plugins: T::Array[Plugin], generator: RbiGenerator, allow_failure: T::Boolean).void }
-    def self.run_plugins(plugins, generator, allow_failure: true); end
-
-    sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-    def initialize(options); end
-
-    sig { abstract.params(root: RbiGenerator::Namespace).void }
-    def generate(root); end
-
-    sig { returns(T.nilable(String)) }
-    attr_accessor :strictness
-  end
-
-  module TypeLoader
-    extend T::Sig
-
-    sig { params(source: String, filename: T.nilable(String), generator: T.nilable(RbiGenerator)).returns(RbiGenerator::Namespace) }
-    def self.load_source(source, filename = nil, generator: nil); end
-
-    sig { params(filename: String, generator: T.nilable(RbiGenerator)).returns(RbiGenerator::Namespace) }
-    def self.load_file(filename, generator: nil); end
-
-    sig do
-      params(
-        root: String,
-        inclusions: T::Array[String],
-        exclusions: T::Array[String],
-        generator: T.nilable(RbiGenerator)
-      ).returns(RbiGenerator::Namespace)
-    end
-    def self.load_project(root, inclusions: ['.'], exclusions: [], generator: nil); end
-  end
-
-  class TypeParser
-    extend T::Sig
-
-    class NodePath
-      extend T::Sig
-
-      sig { returns(T::Array[Integer]) }
-      attr_reader :indices
-
-      sig { params(indices: T::Array[Integer]).void }
-      def initialize(indices); end
-
-      sig { returns(NodePath) }
-      def parent; end
-
-      sig { params(index: Integer).returns(NodePath) }
-      def child(index); end
-
-      sig { params(offset: Integer).returns(NodePath) }
-      def sibling(offset); end
-
-      sig { params(start: Parser::AST::Node).returns(Parser::AST::Node) }
-      def traverse(start); end
-    end
-
-    sig { params(ast: Parser::AST::Node, unknown_node_errors: T::Boolean, generator: T.nilable(RbiGenerator)).void }
-    def initialize(ast, unknown_node_errors: false, generator: nil); end
-
-    sig { params(filename: String, source: String, generator: T.nilable(RbiGenerator)).returns(TypeParser) }
-    def self.from_source(filename, source, generator: nil); end
-
-    sig { returns(Parser::AST::Node) }
-    attr_accessor :ast
-
-    sig { returns(T::Boolean) }
-    attr_reader :unknown_node_errors
-
-    sig { returns(RbiGenerator) }
-    attr_accessor :generator
-
-    sig { returns(RbiGenerator::Namespace) }
-    def parse_all; end
-
-    sig { params(path: NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[RbiGenerator::RbiObject]) }
-    def parse_path_to_object(path, is_within_eigenclass: false); end
-
-    class 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 :params, T.nilable(T::Array[Parser::AST::Node])
-
-    end
-
-    sig { params(path: NodePath).returns(IntermediateSig) }
-    def parse_sig_into_sig(path); end
-
-    sig { params(path: NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[RbiGenerator::Method]) }
-    def parse_sig_into_methods(path, is_within_eigenclass: false); end
-
-    sig { params(path: NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[RbiGenerator::Method]) }
-    def parse_method_into_methods(path, is_within_eigenclass: false); end
-
-    sig { params(str: String).returns(Types::Type) }
-    def self.parse_single_type(str); end
-
-    sig { params(node: Parser::AST::Node).returns(Types::Type) }
-    def parse_node_to_type(node); end
-
-    sig { params(msg: String, node: Parser::AST::Node).void }
-    def warning(msg, node); end
-
-    sig { params(node: T.nilable(Parser::AST::Node)).returns(T::Array[Symbol]) }
-    def constant_names(node); end
-
-    sig { params(node: Parser::AST::Node).returns(T::Boolean) }
-    def sig_node?(node); end
-
-    sig { params(path: NodePath).returns(T::Boolean) }
-    def previous_sibling_sig_node?(path); end
-
-    sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
-    def node_to_s(node); end
-
-    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(desc: String, node: T.any(Parser::AST::Node, NodePath)).returns(T.noreturn) }
-    def parse_err(desc, node); end
-
-    sig do
-      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)]])
-    end
-    def zip_by(a, fa, b, fb); end
-  end
-
-  class TypedObject
-    abstract!
-
-    extend T::Sig
-    extend T::Helpers
-
-    sig { params(name: String).void }
-    def initialize(name); end
-
-    sig { returns(T.nilable(Plugin)) }
-    attr_reader :generated_by
-
-    sig { returns(String) }
-    attr_reader :name
-
-    sig { returns(T::Array[String]) }
-    attr_reader :comments
-
-    sig { params(comment: T.any(String, T::Array[String])).void }
-    def add_comment(comment); end
-
-    sig { abstract.returns(String) }
-    def describe; end
-
-    sig { params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-    def generate_comments(indent_level, options); end
-  end
-
-  module Types
-    TypeLike = T.type_alias { T.any(String, Type) }
-
-    class Type
-      abstract!
-
-      extend T::Sig
-      extend T::Helpers
-
-      sig { abstract.returns(String) }
-      def generate_rbi; end
-
-      sig { abstract.returns(String) }
-      def generate_rbs; end
-
-      sig { params(type_like: TypeLike).returns(Type) }
-      def self.to_type(type_like); end
-
-      sig { params(type_like: TypeLike).returns(Type) }
-      def to_type(type_like); end
-
-      sig { returns(T.untyped) }
-      def hash; end
-
-      sig { abstract.returns(String) }
-      def describe; end
-    end
-
-    class Raw < Type
-      sig { params(str: String).void }
-      def initialize(str); end
-
-      sig { returns(String) }
-      attr_reader :str
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Nilable < Type
-      sig { params(type: TypeLike).void }
-      def initialize(type); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(Type) }
-      attr_reader :type
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Union < Type
-      sig { params(types: T::Array[TypeLike]).void }
-      def initialize(types); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(T::Array[Type]) }
-      attr_reader :types
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Intersection < Type
-      sig { params(types: T::Array[TypeLike]).void }
-      def initialize(types); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(T::Array[Type]) }
-      attr_reader :types
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Tuple < Type
-      sig { params(types: T::Array[TypeLike]).void }
-      def initialize(types); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(T::Array[Type]) }
-      attr_reader :types
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Generic < Type
-      sig { params(type: TypeLike, type_params: T::Array[TypeLike]).void }
-      def initialize(type, type_params); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(Type) }
-      attr_reader :type
-
-      sig { returns(T::Array[Type]) }
-      attr_reader :type_params
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class SingleElementCollection < Type
-      abstract!
-
-      sig { params(element: TypeLike).void }
-      def initialize(element); end
-
-      sig { returns(Type) }
-      attr_reader :element
-
-      sig { abstract.returns(String) }
-      def collection_name; end
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Array < SingleElementCollection
-      sig { override.returns(String) }
-      def collection_name; end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-    end
-
-    class Set < SingleElementCollection
-      sig { override.returns(String) }
-      def collection_name; end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-    end
-
-    class Range < SingleElementCollection
-      sig { override.returns(String) }
-      def collection_name; end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-    end
-
-    class Enumerable < SingleElementCollection
-      sig { override.returns(String) }
-      def collection_name; end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-    end
-
-    class Enumerator < SingleElementCollection
-      sig { override.returns(String) }
-      def collection_name; end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-    end
-
-    class Hash < Type
-      sig { params(key: TypeLike, value: TypeLike).void }
-      def initialize(key, value); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(Type) }
-      attr_reader :key
-
-      sig { returns(Type) }
-      attr_reader :value
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Record < Type
-      sig { params(keys_to_types: T::Hash[Symbol, TypeLike]).void }
-      def initialize(keys_to_types); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(T::Hash[Symbol, Type]) }
-      attr_reader :keys_to_types
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Class < Type
-      sig { params(type: TypeLike).void }
-      def initialize(type); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(Type) }
-      attr_reader :type
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Boolean < Type
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Self < Type
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Untyped < Type
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Proc < Type
-      class Parameter
-        extend T::Sig
-
-        sig { params(name: String, type: TypeLike, default: T.nilable(String)).void }
-        def initialize(name, type, default = nil); end
-
-        sig { returns(String) }
-        attr_reader :name
-
-        sig { returns(Type) }
-        attr_reader :type
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :default
-
-        sig { params(other: Object).returns(T::Boolean) }
-        def ==(other); end
-      end
-
-      sig { params(parameters: T::Array[Parameter], return_type: T.nilable(TypeLike)).void }
-      def initialize(parameters, return_type); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(T::Array[Parameter]) }
-      attr_reader :parameters
-
-      sig { returns(T.nilable(Type)) }
-      attr_reader :return_type
-
-      sig { override.returns(String) }
-      def generate_rbi; end
-
-      sig { override.returns(String) }
-      def generate_rbs; end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-  end
-
-  module Conversion
-    class Converter
-      abstract!
-
-      extend T::Sig
-      extend T::Helpers
-
-      sig { returns(T.untyped) }
-      def initialize; end
-
-      sig { returns(T::Array[[String, TypedObject]]) }
-      attr_reader :warnings
-
-      sig { params(msg: String, node: RbiGenerator::RbiObject).void }
-      def add_warning(msg, node); end
-    end
-
-    class RbiToRbs < Converter
-      extend T::Sig
-
-      sig { params(rbs_gen: RbsGenerator).void }
-      def initialize(rbs_gen); end
-
-      sig { returns(RbsGenerator) }
-      attr_reader :rbs_gen
-
-      sig { params(from: RbiGenerator::Namespace, to: RbsGenerator::Namespace).void }
-      def convert_all(from, to); end
-
-      sig { params(node: RbiGenerator::RbiObject, new_parent: RbsGenerator::Namespace).void }
-      def convert_object(node, new_parent); end
-    end
-  end
-
-  class RbiGenerator < Generator
-    Options = Parlour::Options
-
-    sig { params(hash: T.untyped).returns(T.untyped) }
-    def initialize(**hash); end
-
-    sig { returns(RbiGenerator::Namespace) }
-    attr_reader :root
-
-    sig { overridable.params(strictness: String).returns(String) }
-    def rbi(strictness = 'strong'); end
-
-    class Arbitrary < RbiObject
-      sig { params(generator: Generator, code: String, block: T.nilable(T.proc.params(x: Arbitrary).void)).void }
-      def initialize(generator, code: '', &block); end
-
-      sig { returns(String) }
-      attr_accessor :code
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-    end
-
-    class Attribute < Method
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          kind: Symbol,
-          type: Types::TypeLike,
-          class_attribute: T::Boolean,
-          block: T.nilable(T.proc.params(x: Attribute).void)
-        ).void
-      end
-      def initialize(generator, name, kind, type, class_attribute: false, &block); end
-
-      sig { returns(Symbol) }
-      attr_reader :kind
-
-      sig { returns(T::Boolean) }
-      attr_reader :class_attribute
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { override.params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_definition(indent_level, options); end
-    end
-
-    class ClassNamespace < Namespace
-      extend T::Sig
-
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          final: T::Boolean,
-          sealed: T::Boolean,
-          superclass: T.nilable(String),
-          abstract: T::Boolean,
-          block: T.nilable(T.proc.params(x: ClassNamespace).void)
-        ).void
-      end
-      def initialize(generator, name, final, sealed, superclass, abstract, &block); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :superclass
-
-      sig { returns(T::Boolean) }
-      attr_reader :abstract
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-    end
-
-    class Constant < RbiObject
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          value: Types::TypeLike,
-          eigen_constant: T::Boolean,
-          block: T.nilable(T.proc.params(x: Constant).void)
-        ).void
-      end
-      def initialize(generator, name: '', value: '', eigen_constant: false, &block); end
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :value
-
-      sig { returns(T.untyped) }
-      attr_reader :eigen_constant
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-    end
-
-    class EnumClassNamespace < ClassNamespace
-      extend T::Sig
-
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          final: T::Boolean,
-          sealed: T::Boolean,
-          enums: T::Array[T.any([String, String], String)],
-          abstract: T::Boolean,
-          block: T.nilable(T.proc.params(x: EnumClassNamespace).void)
-        ).void
-      end
-      def initialize(generator, name, final, sealed, enums, abstract, &block); end
-
-      sig { returns(T::Array[T.any([String, String], String)]) }
-      attr_reader :enums
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_body(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-    end
-
-    class Extend < RbiObject
-      sig { params(generator: Generator, name: String, block: T.nilable(T.proc.params(x: Extend).void)).void }
-      def initialize(generator, name: '', &block); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-    end
-
-    class Include < RbiObject
-      sig { params(generator: Generator, name: String, block: T.nilable(T.proc.params(x: Include).void)).void }
-      def initialize(generator, name: '', &block); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-    end
-
-    class Method < RbiObject
-      extend T::Sig
-
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          parameters: T::Array[Parameter],
-          return_type: T.nilable(Types::TypeLike),
-          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: Method).void)
-        ).void
-      end
-      def initialize(generator, name, parameters, return_type = nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, final: false, type_parameters: nil, &block); end
-
-      sig { overridable.params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(T::Array[Parameter]) }
-      attr_reader :parameters
-
-      sig { returns(T.nilable(Types::TypeLike)) }
-      attr_reader :return_type
-
-      sig { returns(T::Boolean) }
-      attr_reader :abstract
-
-      sig { returns(T::Boolean) }
-      attr_reader :implementation
-
-      sig { returns(T::Boolean) }
-      attr_reader :override
-
-      sig { returns(T::Boolean) }
-      attr_reader :overridable
-
-      sig { returns(T::Boolean) }
-      attr_reader :class_method
-
-      sig { returns(T::Boolean) }
-      attr_reader :final
-
-      sig { returns(T::Array[Symbol]) }
-      attr_reader :type_parameters
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-
-      sig { overridable.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_definition(indent_level, options); end
-
-      sig { returns(String) }
-      def qualifiers; end
-    end
-
-    class ModuleNamespace < Namespace
-      extend T::Sig
-
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          final: T::Boolean,
-          sealed: T::Boolean,
-          interface: T::Boolean,
-          abstract: T::Boolean,
-          block: T.nilable(T.proc.params(x: ClassNamespace).void)
-        ).void
-      end
-      def initialize(generator, name, final, sealed, interface, abstract, &block); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig { returns(T::Boolean) }
-      attr_reader :interface
-
-      sig { returns(T::Boolean) }
-      attr_reader :abstract
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-    end
-
-    class Namespace < RbiObject
-      extend T::Sig
-
-      sig { override.overridable.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig do
-        params(
-          generator: Generator,
-          name: T.nilable(String),
-          final: T::Boolean,
-          sealed: T::Boolean,
-          block: T.nilable(T.proc.params(x: Namespace).void)
-        ).void
-      end
-      def initialize(generator, name = nil, final = false, sealed = false, &block); end
-
-      sig { returns(T::Boolean) }
-      attr_reader :final
-
-      sig { returns(T::Boolean) }
-      attr_reader :sealed
-
-      sig { returns(T::Array[RbiObject]) }
-      attr_reader :children
-
-      sig { returns(T::Array[RbiGenerator::Extend]) }
-      def extends; end
-
-      sig { returns(T::Array[RbiGenerator::Include]) }
-      def includes; end
-
-      sig { returns(T::Array[RbiGenerator::TypeAlias]) }
-      def aliases; end
-
-      sig { returns(T::Array[RbiGenerator::Constant]) }
-      def constants; end
-
-      sig { params(object: T.untyped, block: T.proc.params(x: Namespace).void).void }
-      def path(object, &block); end
-
-      sig { params(comment: T.any(String, T::Array[String])).void }
-      def add_comment_to_next_child(comment); end
-
-      sig do
-        params(
-          name: String,
-          final: T::Boolean,
-          sealed: T::Boolean,
-          superclass: T.nilable(String),
-          abstract: T::Boolean,
-          block: T.nilable(T.proc.params(x: ClassNamespace).void)
-        ).returns(ClassNamespace)
-      end
-      def create_class(name, final: false, sealed: false, superclass: nil, abstract: false, &block); end
-
-      sig do
-        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: EnumClassNamespace).void)
-        ).returns(EnumClassNamespace)
-      end
-      def create_enum_class(name, final: false, sealed: false, enums: nil, abstract: false, &block); end
-
-      sig do
-        params(
-          name: String,
-          final: T::Boolean,
-          sealed: T::Boolean,
-          props: T.nilable(T::Array[StructProp]),
-          abstract: T::Boolean,
-          block: T.nilable(T.proc.params(x: StructClassNamespace).void)
-        ).returns(StructClassNamespace)
-      end
-      def create_struct_class(name, final: false, sealed: false, props: nil, abstract: false, &block); end
-
-      sig do
-        params(
-          name: String,
-          final: T::Boolean,
-          sealed: T::Boolean,
-          interface: T::Boolean,
-          abstract: T::Boolean,
-          block: T.nilable(T.proc.params(x: ClassNamespace).void)
-        ).returns(ModuleNamespace)
-      end
-      def create_module(name, final: false, sealed: false, interface: false, abstract: false, &block); end
-
-      sig do
-        params(
-          name: String,
-          parameters: T.nilable(T::Array[Parameter]),
-          return_type: T.nilable(Types::TypeLike),
-          returns: T.nilable(Types::TypeLike),
-          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: Method).void)
-        ).returns(Method)
-      end
-      def create_method(name, parameters: nil, return_type: nil, returns: nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, final: false, type_parameters: nil, &block); end
-
-      sig do
-        params(
-          name: String,
-          kind: Symbol,
-          type: Types::TypeLike,
-          class_attribute: T::Boolean,
-          block: T.nilable(T.proc.params(x: Attribute).void)
-        ).returns(Attribute)
-      end
-      def create_attribute(name, kind:, type:, class_attribute: false, &block); end
-
-      sig do
-        params(
-          name: String,
-          type: Types::TypeLike,
-          class_attribute: T::Boolean,
-          block: T.nilable(T.proc.params(x: Attribute).void)
-        ).returns(Attribute)
-      end
-      def create_attr_reader(name, type:, class_attribute: false, &block); end
-
-      sig do
-        params(
-          name: String,
-          type: Types::TypeLike,
-          class_attribute: T::Boolean,
-          block: T.nilable(T.proc.params(x: Attribute).void)
-        ).returns(Attribute)
-      end
-      def create_attr_writer(name, type:, class_attribute: false, &block); end
-
-      sig do
-        params(
-          name: String,
-          type: Types::TypeLike,
-          class_attribute: T::Boolean,
-          block: T.nilable(T.proc.params(x: Attribute).void)
-        ).returns(Attribute)
-      end
-      def create_attr_accessor(name, type:, class_attribute: false, &block); end
-
-      sig { params(code: T.untyped, block: T.untyped).returns(T.untyped) }
-      def create_arbitrary(code:, &block); end
-
-      sig { params(name: String, block: T.nilable(T.proc.params(x: Extend).void)).returns(RbiGenerator::Extend) }
-      def create_extend(name, &block); end
-
-      sig { params(extendables: T::Array[String]).returns(T::Array[Extend]) }
-      def create_extends(extendables); end
-
-      sig { params(name: String, block: T.nilable(T.proc.params(x: Include).void)).returns(Include) }
-      def create_include(name, &block); end
-
-      sig { params(includables: T::Array[String]).returns(T::Array[Include]) }
-      def create_includes(includables); end
-
-      sig do
-        params(
-          name: String,
-          value: String,
-          eigen_constant: T::Boolean,
-          block: T.nilable(T.proc.params(x: Constant).void)
-        ).returns(Constant)
-      end
-      def create_constant(name, value:, eigen_constant: false, &block); end
-
-      sig { params(name: String, type: Types::TypeLike, block: T.nilable(T.proc.params(x: TypeAlias).void)).returns(TypeAlias) }
-      def create_type_alias(name, type:, &block); end
-
-      sig { override.overridable.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.overridable.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.overridable.returns(String) }
-      def describe; end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-
-      sig { overridable.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_body(indent_level, options); end
-
-      sig { params(object: RbiObject).void }
-      def move_next_comments(object); end
-    end
-
-    class Parameter
-      extend T::Sig
-      PREFIXES = T.let({
-        normal: '',
-        splat: '*',
-        double_splat: '**',
-        block: '&'
-      }.freeze, T::Hash[Symbol, String])
-
-      sig { params(name: String, type: T.nilable(Types::TypeLike), default: T.nilable(String)).void }
-      def initialize(name, type: nil, default: nil); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(String) }
-      attr_reader :name
-
-      sig { returns(String) }
-      def name_without_kind; end
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :default
-
-      sig { returns(Symbol) }
-      attr_reader :kind
-
-      sig { returns(String) }
-      def to_def_param; end
-
-      sig { returns(String) }
-      def to_sig_param; end
-
-      sig { void }
-      def generalize_from_rbi!; end
-    end
-
-    class RbiObject < TypedObject
-      abstract!
-
-      sig { params(generator: Generator, name: String).void }
-      def initialize(generator, name); end
-
-      sig { returns(Generator) }
-      attr_reader :generator
-
-      sig { abstract.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig { abstract.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { abstract.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.overridable.returns(String) }
-      def describe; end
-
-      sig { abstract.void }
-      def generalize_from_rbi!; end
-    end
-
-    class StructClassNamespace < ClassNamespace
-      extend T::Sig
-
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          final: T::Boolean,
-          sealed: T::Boolean,
-          props: T::Array[StructProp],
-          abstract: T::Boolean,
-          block: T.nilable(T.proc.params(x: StructClassNamespace).void)
-        ).void
-      end
-      def initialize(generator, name, final, sealed, props, abstract, &block); end
-
-      sig { returns(T::Array[StructProp]) }
-      attr_reader :props
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_body(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-    end
-
-    class StructProp
-      extend T::Sig
-      EXTRA_PROPERTIES = T.let(%i{
-        optional enum dont_store foreign default factory immutable array override redaction
-      }, T::Array[Symbol])
-
-      sig do
-        params(
-          name: String,
-          type: Types::TypeLike,
-          optional: T.nilable(T.any(T::Boolean, Symbol)),
-          enum: T.nilable(String),
-          dont_store: T.nilable(T::Boolean),
-          foreign: T.nilable(String),
-          default: T.nilable(String),
-          factory: T.nilable(String),
-          immutable: T.nilable(T::Boolean),
-          array: T.nilable(String),
-          override: T.nilable(T::Boolean),
-          redaction: T.nilable(String)
-        ).void
-      end
-      def initialize(name, type, optional: nil, enum: nil, dont_store: nil, foreign: nil, default: nil, factory: nil, immutable: nil, array: nil, override: nil, redaction: nil); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(String) }
-      attr_reader :name
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { returns(T.nilable(T.any(T::Boolean, Symbol))) }
-      attr_reader :optional
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :enum
-
-      sig { returns(T.nilable(T::Boolean)) }
-      attr_reader :dont_store
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :foreign
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :default
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :factory
-
-      sig { returns(T.nilable(T::Boolean)) }
-      attr_reader :immutable
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :array
-
-      sig { returns(T.nilable(T::Boolean)) }
-      attr_reader :override
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :redaction
-
-      sig { returns(String) }
-      def to_prop_call; end
-
-      sig { void }
-      def generalize_from_rbi!; end
-    end
-
-    class TypeAlias < RbiObject
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          type: Types::TypeLike,
-          block: T.nilable(T.proc.params(x: TypeAlias).void)
-        ).void
-      end
-      def initialize(generator, name:, type:, &block); end
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbi(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbiGenerator::RbiObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-
-      sig { override.void }
-      def generalize_from_rbi!; end
-    end
-  end
-
-  class RbsGenerator < Generator
-    sig { params(hash: T.untyped).returns(T.untyped) }
-    def initialize(**hash); end
-
-    sig { returns(RbsGenerator::Namespace) }
-    attr_reader :root
-
-    sig { overridable.returns(String) }
-    def rbs; end
-
-    class Arbitrary < RbsObject
-      sig { params(generator: Generator, code: String, block: T.nilable(T.proc.params(x: Arbitrary).void)).void }
-      def initialize(generator, code: '', &block); end
-
-      sig { returns(String) }
-      attr_accessor :code
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Attribute < RbsGenerator::Method
-      extend T::Sig
-
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          kind: Symbol,
-          type: Types::TypeLike,
-          block: T.nilable(T.proc.params(x: Attribute).void)
-        ).void
-      end
-      def initialize(generator, name, kind, type, &block); end
-
-      sig { returns(Symbol) }
-      attr_reader :kind
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { override.params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-    end
-
-    class Block
-      extend T::Sig
-
-      sig { params(type: Types::Proc, required: T::Boolean).void }
-      def initialize(type, required); end
-
-      sig { overridable.params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(Types::Proc) }
-      attr_reader :type
-
-      sig { returns(T::Boolean) }
-      attr_reader :required
-
-      sig { params(options: Options).returns(T::Array[String]) }
-      def generate_rbs(options); end
-    end
-
-    class ClassNamespace < Namespace
-      extend T::Sig
-
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          superclass: T.nilable(Types::TypeLike),
-          block: T.nilable(T.proc.params(x: ClassNamespace).void)
-        ).void
-      end
-      def initialize(generator, name, superclass, &block); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { returns(T.nilable(Types::TypeLike)) }
-      attr_reader :superclass
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Constant < RbsObject
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          type: Types::TypeLike,
-          block: T.nilable(T.proc.params(x: Constant).void)
-        ).void
-      end
-      def initialize(generator, name, type:, &block); end
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Extend < RbsObject
-      sig { params(generator: Generator, type: Types::TypeLike, block: T.nilable(T.proc.params(x: Extend).void)).void }
-      def initialize(generator, type:, &block); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Include < RbsObject
-      sig { params(generator: Generator, type: Types::TypeLike, block: T.nilable(T.proc.params(x: Include).void)).void }
-      def initialize(generator, type:, &block); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class InterfaceNamespace < Namespace
-      extend T::Sig
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Method < RbsObject
-      extend T::Sig
-
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          signatures: T::Array[MethodSignature],
-          class_method: T::Boolean,
-          block: T.nilable(T.proc.params(x: Method).void)
-        ).void
-      end
-      def initialize(generator, name, signatures, class_method: false, &block); end
-
-      sig { overridable.params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(T::Array[MethodSignature]) }
-      attr_reader :signatures
-
-      sig { returns(T::Boolean) }
-      attr_reader :class_method
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class MethodSignature
-      extend T::Sig
-
-      sig do
-        params(
-          parameters: T::Array[Parameter],
-          return_type: T.nilable(Types::TypeLike),
-          block: T.nilable(Block),
-          type_parameters: T.nilable(T::Array[Symbol])
-        ).void
-      end
-      def initialize(parameters, return_type = nil, block: nil, type_parameters: nil); end
-
-      sig { overridable.params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(T::Array[Parameter]) }
-      attr_reader :parameters
-
-      sig { returns(T.nilable(Types::TypeLike)) }
-      attr_reader :return_type
-
-      sig { returns(T.nilable(Block)) }
-      attr_reader :block
-
-      sig { returns(T::Array[Symbol]) }
-      attr_reader :type_parameters
-
-      sig { params(options: Options).returns(T::Array[String]) }
-      def generate_rbs(options); end
-    end
-
-    class ModuleNamespace < Namespace
-      extend T::Sig
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-
-    class Namespace < RbsObject
-      extend T::Sig
-
-      sig { override.overridable.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { params(generator: Generator, name: T.nilable(String), block: T.nilable(T.proc.params(x: Namespace).void)).void }
-      def initialize(generator, name = nil, &block); end
-
-      sig { returns(T::Array[RbsObject]) }
-      attr_reader :children
-
-      sig { returns(T::Array[RbsGenerator::Extend]) }
-      def extends; end
-
-      sig { returns(T::Array[RbsGenerator::Include]) }
-      def includes; end
-
-      sig { returns(T::Array[RbsGenerator::TypeAlias]) }
-      def aliases; end
-
-      sig { returns(T::Array[RbsGenerator::Constant]) }
-      def constants; end
-
-      sig { params(object: T.untyped, block: T.proc.params(x: Namespace).void).void }
-      def path(object, &block); end
-
-      sig { params(comment: T.any(String, T::Array[String])).void }
-      def add_comment_to_next_child(comment); end
-
-      sig { params(name: String, superclass: T.nilable(Types::TypeLike), block: T.nilable(T.proc.params(x: ClassNamespace).void)).returns(ClassNamespace) }
-      def create_class(name, superclass: nil, &block); end
-
-      sig { params(name: String, block: T.nilable(T.proc.params(x: Namespace).void)).returns(ModuleNamespace) }
-      def create_module(name, &block); end
-
-      sig { params(name: String, block: T.nilable(T.proc.params(x: Namespace).void)).returns(InterfaceNamespace) }
-      def create_interface(name, &block); end
-
-      sig do
-        params(
-          name: String,
-          signatures: T.nilable(T::Array[MethodSignature]),
-          class_method: T::Boolean,
-          block: T.nilable(T.proc.params(x: Method).void)
-        ).returns(Method)
-      end
-      def create_method(name, signatures = nil, class_method: false, &block); end
-
-      sig do
-        params(
-          name: String,
-          kind: Symbol,
-          type: Types::TypeLike,
-          block: T.nilable(T.proc.params(x: Attribute).void)
-        ).returns(Attribute)
-      end
-      def create_attribute(name, kind:, type:, &block); end
-
-      sig { params(name: String, type: Types::TypeLike, block: T.nilable(T.proc.params(x: Attribute).void)).returns(Attribute) }
-      def create_attr_reader(name, type:, &block); end
-
-      sig { params(name: String, type: Types::TypeLike, block: T.nilable(T.proc.params(x: Attribute).void)).returns(Attribute) }
-      def create_attr_writer(name, type:, &block); end
-
-      sig { params(name: String, type: Types::TypeLike, block: T.nilable(T.proc.params(x: Attribute).void)).returns(Attribute) }
-      def create_attr_accessor(name, type:, &block); end
-
-      sig { params(code: T.untyped, block: T.untyped).returns(T.untyped) }
-      def create_arbitrary(code:, &block); end
-
-      sig { params(type: Types::TypeLike, block: T.nilable(T.proc.params(x: Extend).void)).returns(RbsGenerator::Extend) }
-      def create_extend(type, &block); end
-
-      sig { params(extendables: T::Array[Types::TypeLike]).returns(T::Array[Extend]) }
-      def create_extends(extendables); end
-
-      sig { params(type: Types::TypeLike, block: T.nilable(T.proc.params(x: Include).void)).returns(Include) }
-      def create_include(type, &block); end
-
-      sig { params(includables: T::Array[Types::TypeLike]).returns(T::Array[Include]) }
-      def create_includes(includables); end
-
-      sig { params(name: String, type: Types::TypeLike, block: T.nilable(T.proc.params(x: Constant).void)).returns(Constant) }
-      def create_constant(name, type:, &block); end
-
-      sig { params(name: String, type: Types::TypeLike, block: T.nilable(T.proc.params(x: TypeAlias).void)).returns(TypeAlias) }
-      def create_type_alias(name, type:, &block); end
-
-      sig { override.overridable.params(others: T::Array[RbsGenerator::RbsObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.overridable.params(others: T::Array[RbsGenerator::RbsObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.overridable.returns(String) }
-      def describe; end
-
-      sig { overridable.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_body(indent_level, options); end
-
-      sig { params(object: RbsObject).void }
-      def move_next_comments(object); end
-    end
-
-    class Parameter
-      extend T::Sig
-      RBS_KEYWORDS = [
-        'type', 'interface', 'out', 'in', 'instance', 'extension', 'top', 'bot',
-        'self', 'nil', 'void'
-      ]
-      PREFIXES = {
-        normal: '',
-        splat: '*',
-        double_splat: '**',
-      }.freeze
-
-      sig { params(name: String, type: T.nilable(Types::TypeLike), required: T::Boolean).void }
-      def initialize(name, type: nil, required: true); end
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { returns(String) }
-      attr_reader :name
-
-      sig { returns(String) }
-      def name_without_kind; end
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { returns(T::Boolean) }
-      attr_reader :required
-
-      sig { returns(Symbol) }
-      attr_reader :kind
-
-      sig { returns(String) }
-      def to_rbs_param; end
-    end
-
-    class RbsObject < TypedObject
-      abstract!
-
-      sig { params(generator: Generator, name: String).void }
-      def initialize(generator, name); end
-
-      sig { returns(Generator) }
-      attr_reader :generator
-
-      sig { abstract.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { abstract.params(others: T::Array[RbsGenerator::RbsObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { abstract.params(others: T::Array[RbsGenerator::RbsObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.overridable.returns(String) }
-      def describe; end
-    end
-
-    class TypeAlias < RbsObject
-      sig do
-        params(
-          generator: Generator,
-          name: String,
-          type: Types::TypeLike,
-          block: T.nilable(T.proc.params(x: TypeAlias).void)
-        ).void
-      end
-      def initialize(generator, name:, type:, &block); end
-
-      sig { returns(Types::TypeLike) }
-      attr_reader :type
-
-      sig { params(other: Object).returns(T::Boolean) }
-      def ==(other); end
-
-      sig { override.params(indent_level: Integer, options: Options).returns(T::Array[String]) }
-      def generate_rbs(indent_level, options); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).returns(T::Boolean) }
-      def mergeable?(others); end
-
-      sig { override.params(others: T::Array[RbsGenerator::RbsObject]).void }
-      def merge_into_self(others); end
-
-      sig { override.returns(String) }
-      def describe; end
-    end
-  end
-end