sorbet-rails 0.6.5.1 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6f3cc66ce41d3adeddca63531a8d5f6dd98ccc8f936a41d89215ed33423bc2d
-  data.tar.gz: 9ca5aa9adc679b3e230f3a2fa0c1116bd679a42af9df53821ccbbace6ad6db67
+  metadata.gz: 33c9dda20b44067f6f788873f626fd9d2fdf5bbe8a62d8c374e2748b637f5993
+  data.tar.gz: e2d65d1ec7c2e03d7135d7de8540b859c6348d27382732893fff611a5b627d88
 SHA512:
-  metadata.gz: 012505f4ca8d8eed70dba2309dcdecba0fcd76d8695e55e5301fe9c16c033ffccb330acc631a5f38a867f4b8b7dc73e665bad40d3bca767096b741b10c745d95
-  data.tar.gz: c8b3e2eb74c5bc1f44cc3130deb36c693c4b24aeed08698d4c36da28794f12b228c5b855030106e3b4d41f6d79bb71f38c90c674561551621599051629186931
+  metadata.gz: 86a4cc741bef3972a5a8cb3a77d1eaa1f1fe4924d816c5ba681bf6fe5b5d91d0b6e94410a2a08fe15b8d696b80e50b7ff7f4c5a049e58a841fa9d2ecd83fd9c0
+  data.tar.gz: 6120f8d8fdf6e631f92cf6428774cd6df1a410d64282d96ed4921202c1715e2211e15823a510234849615cb7e3dc08368121fd663ad1ab9148ad337123799dca

data/.gitattributes

@@ -1,4 +1,3 @@
-lib/sorbet/* linguist-generated
 spec/test_data/* linguist-generated
 spec/support/* linguist-generated
-
+sorbet/* linguist-generated

data/.gitignore

@@ -79,6 +79,7 @@ build-iPhoneSimulator/
 /spec/support/**/config/credentials.yml.enc
 
 # Ignore sorbet generated files
+/sorbet/rbi/hidden-definitions/
 /spec/support/**/sorbet/*
 /spec/support/**/sorbet/**/*
 
@@ -93,7 +94,7 @@ build-iPhoneSimulator/
 *.swl
 *.swk
 
-lib/sorbet/rbi/hidden-definitions/errors.txt
+sorbet/rbi/hidden-definitions/errors.txt
 .vscode
 
 .rake_tasks~

data/.travis.yml

@@ -16,7 +16,7 @@ rvm:
 matrix:
   include:
   - rvm: 2.5
-    env: RAILS_VERSION=5.2 SORBET_VERSION=0.5.5400
+    env: RAILS_VERSION=5.2 SORBET_VERSION=0.5.6210
   exclude:
   - rvm: 2.3
     env: RAILS_VERSION=6.0

data/README.md

@@ -9,7 +9,7 @@ This gem adds a few Rake tasks to generate Ruby Interface (RBI) files for dynami
 
 `sorbet-rails` supports Rails 5+ or later.
 
-**Notice**: we no longer supports Rails 4.2. [Version 0.5.6](https://github.com/chanzuckerberg/sorbet-rails/releases/tag/v0.5.6) is the last version supporting Rails 4.2.
+**Notice**: we no longer support Rails 4.2. [Version 0.5.6](https://github.com/chanzuckerberg/sorbet-rails/releases/tag/v0.5.6) is the last version supporting Rails 4.2.
 
 ## Initial Setup
 
@@ -43,8 +43,8 @@ Add `sorbet-rails` to the [`:default` group](https://bundler.io/v2.0/guides/grou
 
 4. Update hidden-definition files and automatically upgrade each file's typecheck level:
 ```sh
-❯ srb rbi hidden-definitions
-❯ srb rbi suggest-typed
+❯ bundle exec srb rbi hidden-definitions
+❯ bundle exec srb rbi suggest-typed
 ```
 Because we've generated RBI files for routes, models, and helpers, a lot more files should be typecheckable now. Many methods in `hidden.rbi` may be removed because they are now typed.
 
@@ -94,6 +94,28 @@ Wizard.pluck_to_tstruct(TA[WizardStruct].new)  # T::Array[WizardStruct]
 Wizard.all.pluck_to_tstruct(TA[WizardStruct].new)  # T::Array[WizardStruct]
 ```
 
+You can also pass a keyword argument called `associations` that represents a mapping of a `T::Struct`'s keys to an associated table's columns.
+```ruby
+# -- API
+Arel.pluck_to_tstruct(TA[ <TStructSubclass> ].new, associations: < Hash<Symbol, String> >)
+
+# -- example
+class WizardWithWandStruct < T::Struct
+  const :name, String
+  const :house, T.nilable(String)
+  const :wand_wood_type, String
+end
+
+Wizard.joins(:wand).pluck_to_tstruct(
+  TA[WizardWithWandStruct].new,
+  associations: { wand_wood_type: "wands.wood_type" }
+)
+Wizard.all.joins(:wand).pluck_to_tstruct(
+  TA[WizardWithWandStruct].new,
+  associations: { wand_wood_type: "wands.wood_type" }
+)
+````
+
 This method is based on [pluck_to_hash](https://github.com/girishso/pluck_to_hash) gem.
 
 #### `typed_enum` instead of `enum`
@@ -114,12 +136,14 @@ ie.
 Will generate this enum:
 
 ```ruby
-class Wizard::House < T::Enum
-  enums do
-    Gryffindor = new('Gryffindor')
-    Hufflepuff = new('Hufflepuff')
-    Ravenclaw = new('Ravenclaw')
-    Slytherin = new('Slytherin')
+class Wizard
+  class House < T::Enum
+    enums do
+      Gryffindor = new('Gryffindor')
+      Hufflepuff = new('Hufflepuff')
+      Ravenclaw = new('Ravenclaw')
+      Slytherin = new('Slytherin')
+    end
   end
 end
 ```
@@ -412,11 +436,13 @@ If you run into the following issue when running rspec, it's likely because you'
        if you're really stuck.
 ```
 
-## Extending Model Generation Task with Custom Plugins
+## Extending RBI Generation logic
+
+### Extending Model Generation Task with Custom Plugins
 
 `sorbet-rails` support a customizable plugin system that you can use to generate additional RBI for each model. This will be useful to generate RBI for methods dynamically added by gems or private concerns. If you write plugins for public gems, please feel free to contribute it to this repo.
 
-### Defining a Custom `ModelPlugin`
+#### Defining a Custom `ModelPlugin`
 
 A custom plugin should be a subclass of `SorbetRails::ModelPlugins::Base`. Each plugin would implement a `generate(root)` method that generate additional rbi for the model.
 
@@ -465,14 +491,14 @@ It is also recommended to check if the generated methods are detected by `sorbet
 
 Check out the [plugins](https://github.com/chanzuckerberg/sorbet-rails/tree/master/lib/sorbet-rails/model_plugins) written for `sorbet-rails`'s own model RBI generation logic for examples.
 
-### Registering new plugins
+#### Registering new plugins
 You can register your plugins in an initializer:
 ```ruby
 # -- config/initializers/sorbet_rails.rb
 SorbetRails::ModelRbiFormatter.register_plugin(MyCustomPlugin)
 ```
 
-### Enabling built-in plugins
+#### Enabling built-in plugins
 
 sorbet-rails comes with a handful of gem plugins that can be enabled in an initializer. You can pass enabled gem plugins to `config.enabled_gem_plugins`, like so:
 
@@ -496,6 +522,8 @@ These are the currently-supported gems and their symbolized names:
 | [Shrine]     | `:shrine`      |
 | [active_flag]| `:active_flag` |
 | [Paperclip]  | `:paperclip` |
+| [AttrJson]  | `:attr_json` |
+| [FlagShihTzu]  | `:flag_shih_tzu` |
 
 You can also configure the core model plugins if needed. The default plugins are defined in the [config](https://github.com/chanzuckerberg/sorbet-rails/blob/master/lib/sorbet-rails/config.rb). For the full list of plugin symbols, check out [here](https://github.com/chanzuckerberg/sorbet-rails/blob/master/lib/sorbet-rails/model_plugins/plugins.rb).
 
@@ -507,6 +535,31 @@ You can also configure the core model plugins if needed. The default plugins are
 [Shrine]: https://github.com/shrinerb/shrine
 [active_flag]: https://github.com/kenn/active_flag
 [Paperclip]: https://github.com/thoughtbot/paperclip
+[AttrJson]: https://github.com/jrochkind/attr_json
+[FlagShihTzu]: https://github.com/pboling/flag_shih_tzu
+
+### Customize Generation Class
+
+For mailer and job rbi generation, you can customize the logic by
+setting the generation class in the config:
+
+```ruby
+SorbetRails.configure do |config|
+  config.job_generator_class = CustomJobRbiGenerator
+  config.mailer_generator_class = CustomMailerRbiGenerator
+end
+```
+
+The custom generator can subclass the [provided generators](lib/bundled_rbi/customizabel_rbi_formatter.rbi) and override the populate_rbi method. For example:
+
+```ruby
+class CustomJobRbiGenerator < SorbetRails::JobRbiFormatter
+  def populate_rbi
+    rbi_generator.root.add_comment("== Custom Generator ==")
+    super
+  end
+end
+```
 
 ## Contributing
 

data/Rakefile

@@ -20,9 +20,9 @@ namespace :update_spec do
   task :v6_0 do |t, args|
     Bundler.with_clean_env do
       FileUtils.rm_rf 'spec/support/v6.0' if File.directory?('spec/support/v6.0')
-      system("gem install rails -v 6.0.0")
-      system("rails _6.0.0_ -v")
-      system("RAILS_VERSION='6.0' rails _6.0.0_ new --template spec/generators/rails-template.rb spec/support/v6.0 --skip-javascript --skip-action-cable --skip-test --skip-sprockets --skip-spring --skip-bootsnap --skip-listen")
+      system("gem install rails -v 6.0.3")
+      system("rails _6.0.3_ -v")
+      system("RAILS_VERSION='6.0' rails _6.0.3_ new --template spec/generators/rails-template.rb spec/support/v6.0 --skip-javascript --skip-action-cable --skip-test --skip-sprockets --skip-spring --skip-bootsnap --skip-listen")
     end
   end
 

data/lib/bundled_rbi/customizabel_rbi_formatter.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+module SorbetRails
+  class MailerRbiFormatter
+    extend T::Sig
+    Parameter = ::Parlour::RbiGenerator::Parameter
+
+    sig { returns(T.class_of(ActionMailer::Base)) }
+    attr_reader :mailer_class
+
+    sig { returns(Parlour::RbiGenerator) }
+    def rbi_generator; end
+
+    sig { void }
+    def populate_rbi; end
+  end
+
+  class JobRbiFormatter
+    Parameter = ::Parlour::RbiGenerator::Parameter
+
+    sig { returns(Parlour::RbiGenerator) }
+    attr_reader :rbi_generator
+
+    sig { returns(T.class_of(ActiveJob::Base)) }
+    attr_reader :job_class
+
+    sig { void }
+    def populate_rbi; end
+  end
+end

data/lib/bundled_rbi/pluck_to_tstruct.rbi

@@ -6,10 +6,11 @@ module SorbetRails::PluckToTStruct
     type_parameters(:U).
     params(
       ta_struct: ITypeAssert[T.type_parameter(:U)],
+      associations: T::Hash[Symbol, String],
     ).
     returns(T::Array[T.type_parameter(:U)])
   }
-  def pluck_to_tstruct(ta_struct, &blk); end
+  def pluck_to_tstruct(ta_struct, associations: {}); end
 end
 
 class ActiveRecord::Base

data/lib/bundled_rbi/typed_enum.rbi

@@ -0,0 +1,7 @@
+# typed: strong
+module ActiveRecord::Enum
+
+  sig { params(definitions: T::Hash[Symbol, T.untyped]).void }
+  def typed_enum(definitions); end
+
+end

data/lib/sorbet-rails.rb

@@ -1,11 +1,9 @@
-# typed: strong
+# typed: strict
 module SorbetRails
   if defined?(Rails)
     require 'sorbet-rails/railtie'
     require 'sorbet-rails/model_rbi_formatter'
     require 'sorbet-rails/type_assert/type_assert'
-    require 'sorbet-rails/custom_types/integer_string'
-    require 'sorbet-rails/custom_types/boolean_string'
     require 'sorbet-rails/typed_params'
   end
 end

data/lib/sorbet-rails/active_record_rbi_formatter.rb

@@ -12,7 +12,7 @@ class SorbetRails::ActiveRecordRbiFormatter
 
     parlour = T.let(Parlour::RbiGenerator.new, Parlour::RbiGenerator)
 
-    parlour.root.add_comments([
+    parlour.root.add_comment([
       'This is an autogenerated file for Rails\' ActiveRecord.',
       'Please rerun bundle exec rake rails_rbi:active_record to regenerate.'
     ])
@@ -31,17 +31,17 @@ class SorbetRails::ActiveRecordRbiFormatter
 
     parlour = T.let(Parlour::RbiGenerator.new, Parlour::RbiGenerator)
 
-    parlour.root.add_comments([
+    parlour.root.add_comment([
       'This is an autogenerated file for Rails\' ActiveRecord.',
       'Please rerun bundle exec rake rails_rbi:active_record to regenerate.'
     ])
 
     parlour.root.create_class('ActiveRecord::Relation') do |class_rbi|
       class_rbi.create_include("Enumerable")
-      class_rbi.create_constant(
-        "Elem",
-        value: "type_member(fixed: T.untyped)",
-      )
+      # class_rbi.create_constant(
+      #   "Elem",
+      #   value: "type_member(fixed: T.untyped)",
+      # )
 
       create_elem_specific_query_methods(class_rbi, type: 'Elem', class_method: false)
       create_general_query_methods(class_rbi, class_method: false)

data/lib/sorbet-rails/config.rb

@@ -1,4 +1,7 @@
 # typed: true
+require("sorbet-rails/mailer_rbi_formatter")
+require("sorbet-rails/job_rbi_formatter")
+
 module SorbetRails
   class << self
     extend T::Sig
@@ -37,6 +40,12 @@ module SorbetRails
     sig { returns(T::Array[String]) }
     attr_accessor :extra_helper_includes
 
+    sig { returns(T.class_of(SorbetRails::JobRbiFormatter))}
+    attr_accessor :job_generator_class
+
+    sig { returns(T.class_of(SorbetRails::MailerRbiFormatter))}
+    attr_accessor :mailer_generator_class
+
     sig { void }
     def initialize
       @enabled_gem_plugins = []
@@ -45,6 +54,7 @@ module SorbetRails
         :active_record_named_scope,
         :active_record_querying,
         :active_relation_where_not,
+        :active_record_serialized_attribute,
         :active_record_attribute,
         :active_record_assoc,
         :custom_finder_methods,
@@ -52,6 +62,8 @@ module SorbetRails
       ]
       @enabled_model_plugins << :active_storage_methods if defined?(T.unsafe(ActiveStorage))
       @extra_helper_includes = []
+      @mailer_generator_class = SorbetRails::MailerRbiFormatter
+      @job_generator_class = SorbetRails::JobRbiFormatter
     end
 
     sig { returns(T::Array[Symbol]) }

data/lib/sorbet-rails/dependent_gem_rbis/activerecord.rbi

@@ -12,6 +12,9 @@ class ActiveRecord::Base < Object
   sig { returns(T::Hash[String, T.untyped]) }
   def self.columns_hash; end
 
+  sig { params(column_name: String).returns(T.nilable(T.any(ActiveModel::Type::Value, ActiveRecord::Type::Serialized))) }
+  def self.type_for_attribute(column_name); end
+
   sig { returns(T::Hash[String, T.untyped]) }
   def self.reflections; end
 

data/lib/sorbet-rails/dependent_gem_rbis/parlour.rbi

@@ -0,0 +1,1896 @@
+# typed: strong
+module Kernel
+end
+
+module Parlour
+  VERSION = '6.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(constant: Module, block: T.proc.params(x: Namespace).void).void }
+      def path(constant, &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