Add migration and rake task to migrate FA users to graph database

- Created a new migration to set up Redux Graph tables for storing FA domain objects
- Implemented `Domain::Fa::MigrateUsersToGraph` service to migrate existing FA users to graph nodes
- Added a new rake task `fa:migrate_fa_to_graph` to trigger user migration
- Configured graph database schema to support FA-specific node and edge types
- Added factories and specs to validate graph node creation and associations

This commit sets up the infrastructure for migrating existing FA domain objects to the new graph database model, enabling more flexible and performant data relationships.

app/lib/domain/fa/migrate_users_to_graph.rb

@@ -0,0 +1,25 @@
+# typed: strict
+class Domain::Fa::MigrateUsersToGraph
+  extend T::Sig
+
+  sig { params(start_at_id: T.nilable(Integer)).void }
+  def initialize(start_at_id: nil)
+    @start_at_id = start_at_id
+  end
+
+  sig { void }
+  def run
+    Domain::Fa::User.find_each(start: @start_at_id) do |user|
+      migrate_user(user)
+    end
+  end
+
+  sig { params(user: Domain::Fa::User).void }
+  def migrate_user(user)
+    ReduxGraph::Node::Fa::User.create!(
+      id: user.id,
+      url_name: user.url_name,
+      name: user.name,
+    )
+  end
+end

app/models/redux_graph/edge.rb

@@ -0,0 +1,16 @@
+# typed: strict
+class ReduxGraph::Edge < Graph::Edge
+  self.table_name = "redux_graph_edges"
+
+  sig { override.returns(T.class_of(ReduxGraph::Node)) }
+  def self.node_type
+    ReduxGraph::Node
+  end
+
+  sig { override.returns(T.class_of(ReduxGraph::Edge)) }
+  def self.edge_type
+    ReduxGraph::Edge
+  end
+
+  include Graph::EdgeMixin
+end

app/models/redux_graph/edge/common/creator_has_post.rb

@@ -0,0 +1,4 @@
+# typed: strict
+class ReduxGraph::Edge::Common::CreatorHasPost < ReduxGraph::Edge
+  self.partition = :creator_has_post
+end

app/models/redux_graph/edge/common/node_has_description.rb

@@ -0,0 +1,4 @@
+# typed: strict
+class ReduxGraph::Edge::Common::NodeHasDescription < ReduxGraph::Edge
+  to ReduxGraph::Node::Common::ContentDescription
+end

app/models/redux_graph/edge/common/user_has_avatar.rb

@@ -0,0 +1,4 @@
+# typed: strict
+class ReduxGraph::Edge::Common::UserHasAvatar < ReduxGraph::Edge
+  to ReduxGraph::Node::Common::UserAvatar
+end

app/models/redux_graph/edge/common/user_has_favorite.rb

@@ -0,0 +1,4 @@
+# typed: strict
+class ReduxGraph::Edge::Common::UserHasFavorite < ReduxGraph::Edge
+  self.partition = :user_has_favorite
+end

app/models/redux_graph/node.rb

@@ -0,0 +1,17 @@
+# typed: strict
+class ReduxGraph::Node < Graph::Node
+  self.table_name = "redux_graph_nodes"
+  self.abstract_class = true
+
+  sig { override.returns(T.class_of(ReduxGraph::Node)) }
+  def self.node_type
+    ReduxGraph::Node
+  end
+
+  sig { override.returns(T.class_of(ReduxGraph::Edge)) }
+  def self.edge_type
+    ReduxGraph::Edge
+  end
+
+  include Graph::NodeMixin
+end

app/models/redux_graph/node/common/content_description.rb

@@ -0,0 +1,4 @@
+# typed: strict
+class ReduxGraph::Node::Common::ContentDescription < ReduxGraph::Node
+  virtual_column :content, Graph::ColumnType::String
+end

app/models/redux_graph/node/common/user_avatar.rb

@@ -0,0 +1,5 @@
+# typed: strict
+class ReduxGraph::Node::Common::UserAvatar < ReduxGraph::Node
+  virtual_column :url, Graph::ColumnType::String
+  virtual_belongs_to :file, class_name: BlobFile.name, optional: true
+end

app/models/redux_graph/node/fa/node_base.rb

@@ -0,0 +1,6 @@
+# typed: strict
+module ReduxGraph::Node::Fa
+  class NodeBase < ReduxGraph::Node
+    self.partition = :domain_fa_default
+  end
+end

app/models/redux_graph/node/fa/post.rb

@@ -0,0 +1,44 @@
+# typed: strict
+module ReduxGraph::Node::Fa
+  class Post < NodeBase
+    self.partition = :domain_fa_posts
+
+    belongs_to_node :creator,
+                    edge_type: ReduxGraph::Edge::Common::CreatorHasPost,
+                    node_type: ReduxGraph::Node::Fa::User,
+                    inverse_of: :posts
+
+    has_one_node :description,
+                 edge_type: ReduxGraph::Edge::Common::NodeHasDescription
+
+    belongs_to_many_nodes :favorited_by,
+                          edge_type: ReduxGraph::Edge::Common::UserHasFavorite,
+                          node_type: ReduxGraph::Node::Fa::User,
+                          inverse_of: :favorites
+
+    # title
+    # category
+    # theme
+    # species
+    # gender
+    # description
+    # keywords
+    # num_favorites
+    # num_comments
+    # num_views
+
+    virtual_column :title, Graph::ColumnType::String
+    virtual_column :category, Graph::ColumnType::String
+    virtual_column :theme, Graph::ColumnType::String
+    virtual_column :species, Graph::ColumnType::String
+    virtual_column :gender, Graph::ColumnType::String
+    virtual_column :description, Graph::ColumnType::String
+    virtual_column :keywords, Graph::ColumnType::String, array: true
+
+    virtual_column :num_favorites, Graph::ColumnType::Integer
+    virtual_column :num_comments, Graph::ColumnType::Integer
+    virtual_column :num_views, Graph::ColumnType::Integer
+
+    validates :title, presence: true
+  end
+end

app/models/redux_graph/node/fa/user.rb

@@ -0,0 +1,34 @@
+# typed: strict
+module ReduxGraph::Node::Fa
+  class User < NodeBase
+    self.partition = :domain_fa_users
+
+    has_one_node :profile_description,
+                 edge_type: ReduxGraph::Edge::Common::NodeHasDescription,
+                 node_type: ReduxGraph::Node::Common::ContentDescription
+    has_many_nodes :posts,
+                   edge_type: ReduxGraph::Edge::Common::CreatorHasPost,
+                   node_type: Post,
+                   inverse_of: :creator
+
+    has_many_nodes :favorites,
+                   edge_type: ReduxGraph::Edge::Common::UserHasFavorite,
+                   node_type: Post,
+                   inverse_of: :favorited_by
+
+    has_one_node :avatar,
+                 edge_type: ReduxGraph::Edge::Common::UserHasAvatar,
+                 node_type: ReduxGraph::Node::Common::UserAvatar
+
+    virtual_column :url_name, Graph::ColumnType::String
+    virtual_column :name, Graph::ColumnType::String
+
+    virtual_column :user_page_scanned_at, Graph::ColumnType::Time
+    virtual_column :gallery_scanned_at, Graph::ColumnType::Time
+    virtual_column :favorite_posts_scanned_at, Graph::ColumnType::Time
+    virtual_column :users_being_followed_scanned_at, Graph::ColumnType::Time
+    virtual_column :users_following_me_scanned_at, Graph::ColumnType::Time
+
+    validates :url_name, presence: true
+  end
+end

config/application.rb

@@ -26,6 +26,8 @@ module ReduxScraper
     # all environments use good_job (in external execution mode)
     config.active_job.queue_adapter = :good_job
 
+    config.active_record.schema_format = :sql
+
     # Configuration for the application, engines, and railties goes here.
     #
     # These settings can be overridden in specific environments using the files

db/migrate/20230519002300_create_partitioned_blob_entries.rb

@@ -19,9 +19,9 @@ class CreatePartitionedBlobEntries < ActiveRecord::Migration[7.0]
       partition_table_name = :"blob_entries_p_#{partnum.to_s.rjust(2, "0")}"
       partition_table_sql = <<~SQL.split("\n").map(&:strip).join(" ")
         CREATE TABLE #{partition_table_name}
-        PARTITION OF blob_entries_p FOR 
+        PARTITION OF blob_entries_p FOR
         VALUES WITH (
-            MODULUS #{NUM_PARTITIONS}, 
+            MODULUS #{NUM_PARTITIONS},
             REMAINDER #{partnum}
           )
       SQL

db/migrate/20250106181747_create_graph_tables.rb

@@ -0,0 +1,11 @@
+# typed: strict
+
+class CreateGraphTables < ActiveRecord::Migration[7.2]
+  extend T::Sig
+  include Graph::CreateGraphTable
+
+  sig { void }
+  def change
+    create_graph :redux_graph
+  end
+end

db/migrate/20250110040848_create_graph_domain_fa_enums.rb

@@ -0,0 +1,23 @@
+# typed: strict
+class CreateGraphDomainFaEnums < ActiveRecord::Migration[7.2]
+  extend T::Sig
+  include Graph::CreateGraphTable
+
+  disable_ddl_transaction!
+
+  sig { void }
+  def change
+    change_graph :redux_graph do
+      register_type ReduxGraph::Node
+      register_type ReduxGraph::Node::Fa::Post
+      register_type ReduxGraph::Node::Fa::User
+      register_type ReduxGraph::Node::Common::UserAvatar
+      register_type ReduxGraph::Node::Common::ContentDescription
+      register_type ReduxGraph::Edge
+      register_type ReduxGraph::Edge::Common::CreatorHasPost
+      register_type ReduxGraph::Edge::Common::NodeHasDescription
+      register_type ReduxGraph::Edge::Common::UserHasAvatar
+      register_type ReduxGraph::Edge::Common::UserHasFavorite
+    end
+  end
+end

db/migrate/20250110040849_create_domain_graph_tables.rb

@@ -0,0 +1,12 @@
+# typed: strict
+class CreateDomainGraphTables < ActiveRecord::Migration[7.2]
+  extend T::Sig
+  include Graph::CreateGraphTable
+
+  sig { void }
+  def change
+    change_graph :redux_graph do
+      add_virtual_index ReduxGraph::Node::Fa::User, :url_name, unique: true
+    end
+  end
+end

rake/fa.rake

@@ -300,4 +300,9 @@ namespace :fa do
       batch_size: ENV["batch_size"]&.to_i,
     ).run
   end
+
+  desc "Migrate FA objects to Graph"
+  task migrate_fa_to_graph: :environment do
+    Domain::Fa::MigrateUsersToGraph.new.run
+  end
 end

sorbet/rbi/dsl/application_controller.rbi

@@ -17,6 +17,9 @@ class ApplicationController
     include ::Turbo::FramesHelper
     include ::Turbo::IncludesHelper
     include ::Turbo::StreamsHelper
+    include ::ActionView::Helpers::DateHelper
+    include ::ActionView::Helpers::SanitizeHelper
+    include ::ActionView::Helpers::RenderingHelper
     include ::ActionView::Helpers::CaptureHelper
     include ::ActionView::Helpers::OutputSafetyHelper
     include ::ActionView::Helpers::TagHelper

sorbet/rbi/dsl/devise_controller.rbi

@@ -14,6 +14,9 @@ class DeviseController
     include ::Turbo::FramesHelper
     include ::Turbo::IncludesHelper
     include ::Turbo::StreamsHelper
+    include ::ActionView::Helpers::DateHelper
+    include ::ActionView::Helpers::SanitizeHelper
+    include ::ActionView::Helpers::RenderingHelper
     include ::ActionView::Helpers::CaptureHelper
     include ::ActionView::Helpers::OutputSafetyHelper
     include ::ActionView::Helpers::TagHelper

sorbet/rbi/dsl/rails/application_controller.rbi

@@ -17,6 +17,9 @@ class Rails::ApplicationController
     include ::Turbo::FramesHelper
     include ::Turbo::IncludesHelper
     include ::Turbo::StreamsHelper
+    include ::ActionView::Helpers::DateHelper
+    include ::ActionView::Helpers::SanitizeHelper
+    include ::ActionView::Helpers::RenderingHelper
     include ::ActionView::Helpers::CaptureHelper
     include ::ActionView::Helpers::OutputSafetyHelper
     include ::ActionView::Helpers::TagHelper

sorbet/rbi/dsl/rails/conductor/base_controller.rbi

@@ -17,6 +17,9 @@ class Rails::Conductor::BaseController
     include ::Turbo::FramesHelper
     include ::Turbo::IncludesHelper
     include ::Turbo::StreamsHelper
+    include ::ActionView::Helpers::DateHelper
+    include ::ActionView::Helpers::SanitizeHelper
+    include ::ActionView::Helpers::RenderingHelper
     include ::ActionView::Helpers::CaptureHelper
     include ::ActionView::Helpers::OutputSafetyHelper
     include ::ActionView::Helpers::TagHelper

sorbet/rbi/dsl/rails/health_controller.rbi

@@ -17,6 +17,9 @@ class Rails::HealthController
     include ::Turbo::FramesHelper
     include ::Turbo::IncludesHelper
     include ::Turbo::StreamsHelper
+    include ::ActionView::Helpers::DateHelper
+    include ::ActionView::Helpers::SanitizeHelper
+    include ::ActionView::Helpers::RenderingHelper
     include ::ActionView::Helpers::CaptureHelper
     include ::ActionView::Helpers::OutputSafetyHelper
     include ::ActionView::Helpers::TagHelper

sorbet/rbi/dsl/redux_graph/node/common/content_description.rbi

@@ -0,0 +1,961 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `ReduxGraph::Node::Common::ContentDescription`.
+# Please instead update this file by running `bin/tapioca dsl ReduxGraph::Node::Common::ContentDescription`.
+
+
+class ReduxGraph::Node::Common::ContentDescription
+  include GeneratedAssociationMethods
+  extend CommonRelationMethods
+  extend GeneratedRelationMethods
+
+  private
+
+  sig { returns(NilClass) }
+  def to_ary; end
+
+  class << self
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def new(attributes = nil, &block); end
+  end
+
+  module CommonRelationMethods
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Common::ContentDescription).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def any?(&block); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+    def average(column_name); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def build(attributes = nil, &block); end
+
+    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+    def calculate(operation, column_name); end
+
+    sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) }
+    sig do
+      params(
+        column_name: NilClass,
+        block: T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void
+      ).returns(Integer)
+    end
+    def count(column_name = nil, &block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def create(attributes = nil, &block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def create!(attributes = nil, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def create_or_find_by(attributes, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def create_or_find_by!(attributes, &block); end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def destroy_all; end
+
+    sig { params(conditions: T.untyped).returns(T::Boolean) }
+    def exists?(conditions = :none); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    def fifth; end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def fifth!; end
+
+    sig do
+      params(
+        args: T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    sig do
+      params(
+        args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])]
+      ).returns(T::Enumerable[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        args: NilClass,
+        block: T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void
+      ).returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription))
+    end
+    def find(args = nil, &block); end
+
+    sig { params(args: T.untyped).returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    def find_by(*args); end
+
+    sig { params(args: T.untyped).returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def find_by!(*args); end
+
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        block: T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void
+      ).void
+    end
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol
+      ).returns(T::Enumerator[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
+
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        block: T.proc.params(object: T::Array[::ReduxGraph::Node::Common::ContentDescription]).void
+      ).void
+    end
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol
+      ).returns(T::Enumerator[T::Enumerator[::ReduxGraph::Node::Common::ContentDescription]])
+    end
+    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def find_or_create_by(attributes, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def find_or_create_by!(attributes, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def find_or_initialize_by(attributes, &block); end
+
+    sig do
+      params(
+        signed_id: T.untyped,
+        purpose: T.untyped
+      ).returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription))
+    end
+    def find_signed(signed_id, purpose: nil); end
+
+    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def find_signed!(signed_id, purpose: nil); end
+
+    sig { params(arg: T.untyped, args: T.untyped).returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def find_sole_by(arg, *args); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    sig { params(limit: Integer).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def first(limit = nil); end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def first!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    def forty_two; end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def forty_two!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    def fourth; end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def fourth!; end
+
+    sig { returns(Array) }
+    def ids; end
+
+    sig do
+      params(
+        of: Integer,
+        start: T.untyped,
+        finish: T.untyped,
+        load: T.untyped,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        use_ranges: T.untyped,
+        block: T.proc.params(object: PrivateRelation).void
+      ).void
+    end
+    sig do
+      params(
+        of: Integer,
+        start: T.untyped,
+        finish: T.untyped,
+        load: T.untyped,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        use_ranges: T.untyped
+      ).returns(::ActiveRecord::Batches::BatchEnumerator)
+    end
+    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end
+
+    sig { params(record: T.untyped).returns(T::Boolean) }
+    def include?(record); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    sig { params(limit: Integer).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def last(limit = nil); end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def last!; end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Common::ContentDescription).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def many?(&block); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+    def maximum(column_name); end
+
+    sig { params(record: T.untyped).returns(T::Boolean) }
+    def member?(record); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+    def minimum(column_name); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).void)
+      ).returns(::ReduxGraph::Node::Common::ContentDescription)
+    end
+    def new(attributes = nil, &block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Common::ContentDescription).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def none?(&block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Common::ContentDescription).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def one?(&block); end
+
+    sig { params(column_names: T.untyped).returns(T.untyped) }
+    def pick(*column_names); end
+
+    sig { params(column_names: T.untyped).returns(T.untyped) }
+    def pluck(*column_names); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    def second; end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def second!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    def second_to_last; end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def second_to_last!; end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def sole; end
+
+    sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) }
+    sig do
+      type_parameters(:U)
+        .params(
+          initial_value_or_column: T.nilable(T.type_parameter(:U)),
+          block: T.proc.params(object: ::ReduxGraph::Node::Common::ContentDescription).returns(T.type_parameter(:U))
+        ).returns(T.type_parameter(:U))
+    end
+    def sum(initial_value_or_column = nil, &block); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    sig { params(limit: Integer).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def take(limit = nil); end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def take!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    def third; end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def third!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::ContentDescription)) }
+    def third_to_last; end
+
+    sig { returns(::ReduxGraph::Node::Common::ContentDescription) }
+    def third_to_last!; end
+  end
+
+  module GeneratedAssociationMethods
+    sig { returns(T::Array[T.untyped]) }
+    def incoming_edge_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def incoming_edge_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :incoming_edges`.
+    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def incoming_edges; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def incoming_edges=(value); end
+
+    sig { returns(T::Array[T.untyped]) }
+    def incoming_node_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def incoming_node_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :incoming_nodes, through: :incoming_edges`.
+    # 🔗 [Rails guide for `has_many_through` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def incoming_nodes; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def incoming_nodes=(value); end
+
+    sig { returns(T::Array[T.untyped]) }
+    def outgoing_edge_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def outgoing_edge_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :outgoing_edges`.
+    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def outgoing_edges; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def outgoing_edges=(value); end
+
+    sig { returns(T::Array[T.untyped]) }
+    def outgoing_node_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def outgoing_node_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :outgoing_nodes, through: :outgoing_edges`.
+    # 🔗 [Rails guide for `has_many_through` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def outgoing_nodes; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def outgoing_nodes=(value); end
+  end
+
+  module GeneratedAssociationRelationMethods
+    sig { returns(PrivateAssociationRelation) }
+    def all; end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def and(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def annotate(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def arel_columns(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def create_with(*args, &blk); end
+
+    sig { params(value: T::Boolean).returns(PrivateAssociationRelation) }
+    def distinct(value = true); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def eager_load(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def except(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def excluding(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def extending(*args, &blk); end
+
+    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+    def extract_associated(association); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def from(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationGroupChain) }
+    def group(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def having(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def in_order_of(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def includes(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def invert_where(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def left_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def left_outer_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def limit(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def lock(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def merge(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def none(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def null_relation?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def offset(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def only(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def optimizer_hints(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def or(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def preload(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def readonly(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def references(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def regroup(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def reorder(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def reselect(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def reverse_order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def rewhere(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def select(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def strict_loading(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def structurally_compatible?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def uniq!(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def unscope(*args, &blk); end
+
+    sig { returns(PrivateAssociationRelationWhereChain) }
+    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+    def where(*args); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def with(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def with_recursive(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def without(*args, &blk); end
+  end
+
+  module GeneratedRelationMethods
+    sig { returns(PrivateRelation) }
+    def all; end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def and(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def annotate(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def arel_columns(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def create_with(*args, &blk); end
+
+    sig { params(value: T::Boolean).returns(PrivateRelation) }
+    def distinct(value = true); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def eager_load(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def except(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def excluding(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def extending(*args, &blk); end
+
+    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+    def extract_associated(association); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def from(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationGroupChain) }
+    def group(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def having(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def in_order_of(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def includes(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def invert_where(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def left_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def left_outer_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def limit(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def lock(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def merge(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def none(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def null_relation?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def offset(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def only(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def optimizer_hints(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def or(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def preload(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def readonly(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def references(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def regroup(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def reorder(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def reselect(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def reverse_order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def rewhere(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def select(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def strict_loading(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def structurally_compatible?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def uniq!(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def unscope(*args, &blk); end
+
+    sig { returns(PrivateRelationWhereChain) }
+    sig { params(args: T.untyped).returns(PrivateRelation) }
+    def where(*args); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def with(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def with_recursive(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def without(*args, &blk); end
+  end
+
+  class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation
+    include CommonRelationMethods
+    include GeneratedAssociationRelationMethods
+
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::ContentDescription } }
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def to_a; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def to_ary; end
+  end
+
+  class PrivateAssociationRelationGroupChain < PrivateAssociationRelation
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::ContentDescription } }
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+    def average(column_name); end
+
+    sig do
+      params(
+        operation: Symbol,
+        column_name: T.any(String, Symbol)
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def calculate(operation, column_name); end
+
+    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+    def count(column_name = nil); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+    def having(*args, &blk); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def maximum(column_name); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def minimum(column_name); end
+
+    sig do
+      params(
+        column_name: T.nilable(T.any(String, Symbol)),
+        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def sum(column_name = nil, &block); end
+  end
+
+  class PrivateAssociationRelationWhereChain
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::ContentDescription } }
+
+    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+    def associated(*args); end
+
+    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+    def missing(*args); end
+
+    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) }
+    def not(opts, *rest); end
+  end
+
+  class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy
+    include CommonRelationMethods
+    include GeneratedAssociationRelationMethods
+
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::ContentDescription } }
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[::ReduxGraph::Node::Common::ContentDescription])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def <<(*records); end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[::ReduxGraph::Node::Common::ContentDescription])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def append(*records); end
+
+    sig { returns(PrivateCollectionProxy) }
+    def clear; end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[::ReduxGraph::Node::Common::ContentDescription])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def concat(*records); end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def load_target; end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[::ReduxGraph::Node::Common::ContentDescription])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def prepend(*records); end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[::ReduxGraph::Node::Common::ContentDescription])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def push(*records); end
+
+    sig do
+      params(
+        other_array: T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[T.any(::ReduxGraph::Node::Common::ContentDescription, T::Enumerable[::ReduxGraph::Node::Common::ContentDescription])])
+      ).returns(T::Array[::ReduxGraph::Node::Common::ContentDescription])
+    end
+    def replace(other_array); end
+
+    sig { returns(PrivateAssociationRelation) }
+    def scope; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def target; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def to_a; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def to_ary; end
+  end
+
+  class PrivateRelation < ::ActiveRecord::Relation
+    include CommonRelationMethods
+    include GeneratedRelationMethods
+
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::ContentDescription } }
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def to_a; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::ContentDescription]) }
+    def to_ary; end
+  end
+
+  class PrivateRelationGroupChain < PrivateRelation
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::ContentDescription } }
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+    def average(column_name); end
+
+    sig do
+      params(
+        operation: Symbol,
+        column_name: T.any(String, Symbol)
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def calculate(operation, column_name); end
+
+    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+    def count(column_name = nil); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+    def having(*args, &blk); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def maximum(column_name); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def minimum(column_name); end
+
+    sig do
+      params(
+        column_name: T.nilable(T.any(String, Symbol)),
+        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def sum(column_name = nil, &block); end
+  end
+
+  class PrivateRelationWhereChain
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::ContentDescription } }
+
+    sig { params(args: T.untyped).returns(PrivateRelation) }
+    def associated(*args); end
+
+    sig { params(args: T.untyped).returns(PrivateRelation) }
+    def missing(*args); end
+
+    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) }
+    def not(opts, *rest); end
+  end
+end

sorbet/rbi/dsl/redux_graph/node/common/user_avatar.rbi

@@ -0,0 +1,983 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `ReduxGraph::Node::Common::UserAvatar`.
+# Please instead update this file by running `bin/tapioca dsl ReduxGraph::Node::Common::UserAvatar`.
+
+
+class ReduxGraph::Node::Common::UserAvatar
+  include GeneratedAssociationMethods
+  extend CommonRelationMethods
+  extend GeneratedRelationMethods
+
+  private
+
+  sig { returns(NilClass) }
+  def to_ary; end
+
+  class << self
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def new(attributes = nil, &block); end
+  end
+
+  module CommonRelationMethods
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Common::UserAvatar).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def any?(&block); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+    def average(column_name); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def build(attributes = nil, &block); end
+
+    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+    def calculate(operation, column_name); end
+
+    sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) }
+    sig do
+      params(
+        column_name: NilClass,
+        block: T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void
+      ).returns(Integer)
+    end
+    def count(column_name = nil, &block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def create(attributes = nil, &block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def create!(attributes = nil, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def create_or_find_by(attributes, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def create_or_find_by!(attributes, &block); end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def destroy_all; end
+
+    sig { params(conditions: T.untyped).returns(T::Boolean) }
+    def exists?(conditions = :none); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    def fifth; end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def fifth!; end
+
+    sig do
+      params(
+        args: T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    sig do
+      params(
+        args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])]
+      ).returns(T::Enumerable[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        args: NilClass,
+        block: T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void
+      ).returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar))
+    end
+    def find(args = nil, &block); end
+
+    sig { params(args: T.untyped).returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    def find_by(*args); end
+
+    sig { params(args: T.untyped).returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def find_by!(*args); end
+
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        block: T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void
+      ).void
+    end
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol
+      ).returns(T::Enumerator[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
+
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        block: T.proc.params(object: T::Array[::ReduxGraph::Node::Common::UserAvatar]).void
+      ).void
+    end
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol
+      ).returns(T::Enumerator[T::Enumerator[::ReduxGraph::Node::Common::UserAvatar]])
+    end
+    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def find_or_create_by(attributes, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def find_or_create_by!(attributes, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def find_or_initialize_by(attributes, &block); end
+
+    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    def find_signed(signed_id, purpose: nil); end
+
+    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def find_signed!(signed_id, purpose: nil); end
+
+    sig { params(arg: T.untyped, args: T.untyped).returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def find_sole_by(arg, *args); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    sig { params(limit: Integer).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def first(limit = nil); end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def first!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    def forty_two; end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def forty_two!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    def fourth; end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def fourth!; end
+
+    sig { returns(Array) }
+    def ids; end
+
+    sig do
+      params(
+        of: Integer,
+        start: T.untyped,
+        finish: T.untyped,
+        load: T.untyped,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        use_ranges: T.untyped,
+        block: T.proc.params(object: PrivateRelation).void
+      ).void
+    end
+    sig do
+      params(
+        of: Integer,
+        start: T.untyped,
+        finish: T.untyped,
+        load: T.untyped,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        use_ranges: T.untyped
+      ).returns(::ActiveRecord::Batches::BatchEnumerator)
+    end
+    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end
+
+    sig { params(record: T.untyped).returns(T::Boolean) }
+    def include?(record); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    sig { params(limit: Integer).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def last(limit = nil); end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def last!; end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Common::UserAvatar).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def many?(&block); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+    def maximum(column_name); end
+
+    sig { params(record: T.untyped).returns(T::Boolean) }
+    def member?(record); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+    def minimum(column_name); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).void)
+      ).returns(::ReduxGraph::Node::Common::UserAvatar)
+    end
+    def new(attributes = nil, &block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Common::UserAvatar).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def none?(&block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Common::UserAvatar).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def one?(&block); end
+
+    sig { params(column_names: T.untyped).returns(T.untyped) }
+    def pick(*column_names); end
+
+    sig { params(column_names: T.untyped).returns(T.untyped) }
+    def pluck(*column_names); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    def second; end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def second!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    def second_to_last; end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def second_to_last!; end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def sole; end
+
+    sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) }
+    sig do
+      type_parameters(:U)
+        .params(
+          initial_value_or_column: T.nilable(T.type_parameter(:U)),
+          block: T.proc.params(object: ::ReduxGraph::Node::Common::UserAvatar).returns(T.type_parameter(:U))
+        ).returns(T.type_parameter(:U))
+    end
+    def sum(initial_value_or_column = nil, &block); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    sig { params(limit: Integer).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def take(limit = nil); end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def take!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    def third; end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def third!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Common::UserAvatar)) }
+    def third_to_last; end
+
+    sig { returns(::ReduxGraph::Node::Common::UserAvatar) }
+    def third_to_last!; end
+  end
+
+  module GeneratedAssociationMethods
+    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+    def build_file(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+    def create_file(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+    def create_file!(*args, &blk); end
+
+    sig { returns(T.untyped) }
+    def file; end
+
+    sig { params(value: T.untyped).void }
+    def file=(value); end
+
+    sig { returns(T::Boolean) }
+    def file_changed?; end
+
+    sig { returns(T::Boolean) }
+    def file_previously_changed?; end
+
+    sig { returns(T::Array[T.untyped]) }
+    def incoming_edge_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def incoming_edge_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :incoming_edges`.
+    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def incoming_edges; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def incoming_edges=(value); end
+
+    sig { returns(T::Array[T.untyped]) }
+    def incoming_node_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def incoming_node_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :incoming_nodes, through: :incoming_edges`.
+    # 🔗 [Rails guide for `has_many_through` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def incoming_nodes; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def incoming_nodes=(value); end
+
+    sig { returns(T::Array[T.untyped]) }
+    def outgoing_edge_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def outgoing_edge_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :outgoing_edges`.
+    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def outgoing_edges; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def outgoing_edges=(value); end
+
+    sig { returns(T::Array[T.untyped]) }
+    def outgoing_node_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def outgoing_node_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :outgoing_nodes, through: :outgoing_edges`.
+    # 🔗 [Rails guide for `has_many_through` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def outgoing_nodes; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def outgoing_nodes=(value); end
+
+    sig { returns(T.untyped) }
+    def reload_file; end
+
+    sig { void }
+    def reset_file; end
+  end
+
+  module GeneratedAssociationRelationMethods
+    sig { returns(PrivateAssociationRelation) }
+    def all; end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def and(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def annotate(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def arel_columns(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def create_with(*args, &blk); end
+
+    sig { params(value: T::Boolean).returns(PrivateAssociationRelation) }
+    def distinct(value = true); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def eager_load(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def except(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def excluding(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def extending(*args, &blk); end
+
+    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+    def extract_associated(association); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def from(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationGroupChain) }
+    def group(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def having(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def in_order_of(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def includes(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def invert_where(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def left_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def left_outer_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def limit(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def lock(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def merge(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def none(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def null_relation?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def offset(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def only(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def optimizer_hints(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def or(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def preload(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def readonly(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def references(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def regroup(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def reorder(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def reselect(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def reverse_order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def rewhere(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def select(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def strict_loading(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def structurally_compatible?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def uniq!(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def unscope(*args, &blk); end
+
+    sig { returns(PrivateAssociationRelationWhereChain) }
+    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+    def where(*args); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def with(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def with_recursive(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def without(*args, &blk); end
+  end
+
+  module GeneratedRelationMethods
+    sig { returns(PrivateRelation) }
+    def all; end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def and(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def annotate(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def arel_columns(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def create_with(*args, &blk); end
+
+    sig { params(value: T::Boolean).returns(PrivateRelation) }
+    def distinct(value = true); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def eager_load(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def except(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def excluding(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def extending(*args, &blk); end
+
+    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+    def extract_associated(association); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def from(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationGroupChain) }
+    def group(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def having(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def in_order_of(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def includes(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def invert_where(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def left_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def left_outer_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def limit(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def lock(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def merge(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def none(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def null_relation?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def offset(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def only(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def optimizer_hints(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def or(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def preload(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def readonly(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def references(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def regroup(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def reorder(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def reselect(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def reverse_order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def rewhere(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def select(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def strict_loading(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def structurally_compatible?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def uniq!(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def unscope(*args, &blk); end
+
+    sig { returns(PrivateRelationWhereChain) }
+    sig { params(args: T.untyped).returns(PrivateRelation) }
+    def where(*args); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def with(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def with_recursive(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def without(*args, &blk); end
+  end
+
+  class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation
+    include CommonRelationMethods
+    include GeneratedAssociationRelationMethods
+
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::UserAvatar } }
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def to_a; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def to_ary; end
+  end
+
+  class PrivateAssociationRelationGroupChain < PrivateAssociationRelation
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::UserAvatar } }
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+    def average(column_name); end
+
+    sig do
+      params(
+        operation: Symbol,
+        column_name: T.any(String, Symbol)
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def calculate(operation, column_name); end
+
+    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+    def count(column_name = nil); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+    def having(*args, &blk); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def maximum(column_name); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def minimum(column_name); end
+
+    sig do
+      params(
+        column_name: T.nilable(T.any(String, Symbol)),
+        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def sum(column_name = nil, &block); end
+  end
+
+  class PrivateAssociationRelationWhereChain
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::UserAvatar } }
+
+    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+    def associated(*args); end
+
+    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+    def missing(*args); end
+
+    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) }
+    def not(opts, *rest); end
+  end
+
+  class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy
+    include CommonRelationMethods
+    include GeneratedAssociationRelationMethods
+
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::UserAvatar } }
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[::ReduxGraph::Node::Common::UserAvatar])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def <<(*records); end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[::ReduxGraph::Node::Common::UserAvatar])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def append(*records); end
+
+    sig { returns(PrivateCollectionProxy) }
+    def clear; end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[::ReduxGraph::Node::Common::UserAvatar])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def concat(*records); end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def load_target; end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[::ReduxGraph::Node::Common::UserAvatar])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def prepend(*records); end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[::ReduxGraph::Node::Common::UserAvatar])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def push(*records); end
+
+    sig do
+      params(
+        other_array: T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[T.any(::ReduxGraph::Node::Common::UserAvatar, T::Enumerable[::ReduxGraph::Node::Common::UserAvatar])])
+      ).returns(T::Array[::ReduxGraph::Node::Common::UserAvatar])
+    end
+    def replace(other_array); end
+
+    sig { returns(PrivateAssociationRelation) }
+    def scope; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def target; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def to_a; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def to_ary; end
+  end
+
+  class PrivateRelation < ::ActiveRecord::Relation
+    include CommonRelationMethods
+    include GeneratedRelationMethods
+
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::UserAvatar } }
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def to_a; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Common::UserAvatar]) }
+    def to_ary; end
+  end
+
+  class PrivateRelationGroupChain < PrivateRelation
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::UserAvatar } }
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+    def average(column_name); end
+
+    sig do
+      params(
+        operation: Symbol,
+        column_name: T.any(String, Symbol)
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def calculate(operation, column_name); end
+
+    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+    def count(column_name = nil); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+    def having(*args, &blk); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def maximum(column_name); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def minimum(column_name); end
+
+    sig do
+      params(
+        column_name: T.nilable(T.any(String, Symbol)),
+        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def sum(column_name = nil, &block); end
+  end
+
+  class PrivateRelationWhereChain
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Common::UserAvatar } }
+
+    sig { params(args: T.untyped).returns(PrivateRelation) }
+    def associated(*args); end
+
+    sig { params(args: T.untyped).returns(PrivateRelation) }
+    def missing(*args); end
+
+    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) }
+    def not(opts, *rest); end
+  end
+end

sorbet/rbi/dsl/redux_graph/node/fa/node_base.rbi

@@ -0,0 +1,956 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `ReduxGraph::Node::Fa::NodeBase`.
+# Please instead update this file by running `bin/tapioca dsl ReduxGraph::Node::Fa::NodeBase`.
+
+
+class ReduxGraph::Node::Fa::NodeBase
+  include GeneratedAssociationMethods
+  extend CommonRelationMethods
+  extend GeneratedRelationMethods
+
+  private
+
+  sig { returns(NilClass) }
+  def to_ary; end
+
+  class << self
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def new(attributes = nil, &block); end
+  end
+
+  module CommonRelationMethods
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Fa::NodeBase).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def any?(&block); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+    def average(column_name); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def build(attributes = nil, &block); end
+
+    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+    def calculate(operation, column_name); end
+
+    sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) }
+    sig do
+      params(
+        column_name: NilClass,
+        block: T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void
+      ).returns(Integer)
+    end
+    def count(column_name = nil, &block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def create(attributes = nil, &block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def create!(attributes = nil, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def create_or_find_by(attributes, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def create_or_find_by!(attributes, &block); end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def destroy_all; end
+
+    sig { params(conditions: T.untyped).returns(T::Boolean) }
+    def exists?(conditions = :none); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    def fifth; end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def fifth!; end
+
+    sig do
+      params(
+        args: T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    sig do
+      params(
+        args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])]
+      ).returns(T::Enumerable[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        args: NilClass,
+        block: T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void
+      ).returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase))
+    end
+    def find(args = nil, &block); end
+
+    sig { params(args: T.untyped).returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    def find_by(*args); end
+
+    sig { params(args: T.untyped).returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def find_by!(*args); end
+
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        block: T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void
+      ).void
+    end
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol
+      ).returns(T::Enumerator[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
+
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        block: T.proc.params(object: T::Array[::ReduxGraph::Node::Fa::NodeBase]).void
+      ).void
+    end
+    sig do
+      params(
+        start: T.untyped,
+        finish: T.untyped,
+        batch_size: Integer,
+        error_on_ignore: T.untyped,
+        order: Symbol
+      ).returns(T::Enumerator[T::Enumerator[::ReduxGraph::Node::Fa::NodeBase]])
+    end
+    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def find_or_create_by(attributes, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def find_or_create_by!(attributes, &block); end
+
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def find_or_initialize_by(attributes, &block); end
+
+    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    def find_signed(signed_id, purpose: nil); end
+
+    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def find_signed!(signed_id, purpose: nil); end
+
+    sig { params(arg: T.untyped, args: T.untyped).returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def find_sole_by(arg, *args); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    sig { params(limit: Integer).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def first(limit = nil); end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def first!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    def forty_two; end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def forty_two!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    def fourth; end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def fourth!; end
+
+    sig { returns(Array) }
+    def ids; end
+
+    sig do
+      params(
+        of: Integer,
+        start: T.untyped,
+        finish: T.untyped,
+        load: T.untyped,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        use_ranges: T.untyped,
+        block: T.proc.params(object: PrivateRelation).void
+      ).void
+    end
+    sig do
+      params(
+        of: Integer,
+        start: T.untyped,
+        finish: T.untyped,
+        load: T.untyped,
+        error_on_ignore: T.untyped,
+        order: Symbol,
+        use_ranges: T.untyped
+      ).returns(::ActiveRecord::Batches::BatchEnumerator)
+    end
+    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end
+
+    sig { params(record: T.untyped).returns(T::Boolean) }
+    def include?(record); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    sig { params(limit: Integer).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def last(limit = nil); end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def last!; end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Fa::NodeBase).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def many?(&block); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+    def maximum(column_name); end
+
+    sig { params(record: T.untyped).returns(T::Boolean) }
+    def member?(record); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+    def minimum(column_name); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    sig do
+      params(
+        attributes: T::Array[T.untyped],
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    sig do
+      params(
+        attributes: T.untyped,
+        block: T.nilable(T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).void)
+      ).returns(::ReduxGraph::Node::Fa::NodeBase)
+    end
+    def new(attributes = nil, &block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Fa::NodeBase).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def none?(&block); end
+
+    sig do
+      params(
+        block: T.nilable(T.proc.params(record: ::ReduxGraph::Node::Fa::NodeBase).returns(T.untyped))
+      ).returns(T::Boolean)
+    end
+    def one?(&block); end
+
+    sig { params(column_names: T.untyped).returns(T.untyped) }
+    def pick(*column_names); end
+
+    sig { params(column_names: T.untyped).returns(T.untyped) }
+    def pluck(*column_names); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    def second; end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def second!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    def second_to_last; end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def second_to_last!; end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def sole; end
+
+    sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) }
+    sig do
+      type_parameters(:U)
+        .params(
+          initial_value_or_column: T.nilable(T.type_parameter(:U)),
+          block: T.proc.params(object: ::ReduxGraph::Node::Fa::NodeBase).returns(T.type_parameter(:U))
+        ).returns(T.type_parameter(:U))
+    end
+    def sum(initial_value_or_column = nil, &block); end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    sig { params(limit: Integer).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def take(limit = nil); end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def take!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    def third; end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def third!; end
+
+    sig { returns(T.nilable(::ReduxGraph::Node::Fa::NodeBase)) }
+    def third_to_last; end
+
+    sig { returns(::ReduxGraph::Node::Fa::NodeBase) }
+    def third_to_last!; end
+  end
+
+  module GeneratedAssociationMethods
+    sig { returns(T::Array[T.untyped]) }
+    def incoming_edge_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def incoming_edge_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :incoming_edges`.
+    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def incoming_edges; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def incoming_edges=(value); end
+
+    sig { returns(T::Array[T.untyped]) }
+    def incoming_node_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def incoming_node_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :incoming_nodes, through: :incoming_edges`.
+    # 🔗 [Rails guide for `has_many_through` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def incoming_nodes; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def incoming_nodes=(value); end
+
+    sig { returns(T::Array[T.untyped]) }
+    def outgoing_edge_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def outgoing_edge_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :outgoing_edges`.
+    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def outgoing_edges; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def outgoing_edges=(value); end
+
+    sig { returns(T::Array[T.untyped]) }
+    def outgoing_node_ids; end
+
+    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+    def outgoing_node_ids=(ids); end
+
+    # This method is created by ActiveRecord on the `ReduxGraph::Node` class because it declared `has_many :outgoing_nodes, through: :outgoing_edges`.
+    # 🔗 [Rails guide for `has_many_through` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association)
+    sig { returns(ActiveRecord::Associations::CollectionProxy) }
+    def outgoing_nodes; end
+
+    sig { params(value: T::Enumerable[T.untyped]).void }
+    def outgoing_nodes=(value); end
+  end
+
+  module GeneratedAssociationRelationMethods
+    sig { returns(PrivateAssociationRelation) }
+    def all; end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def and(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def annotate(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def arel_columns(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def create_with(*args, &blk); end
+
+    sig { params(value: T::Boolean).returns(PrivateAssociationRelation) }
+    def distinct(value = true); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def eager_load(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def except(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def excluding(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def extending(*args, &blk); end
+
+    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+    def extract_associated(association); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def from(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationGroupChain) }
+    def group(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def having(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def in_order_of(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def includes(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def invert_where(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def left_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def left_outer_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def limit(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def lock(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def merge(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def none(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def null_relation?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def offset(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def only(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def optimizer_hints(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def or(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def preload(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def readonly(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def references(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def regroup(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def reorder(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def reselect(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def reverse_order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def rewhere(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def select(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def strict_loading(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def structurally_compatible?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def uniq!(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def unscope(*args, &blk); end
+
+    sig { returns(PrivateAssociationRelationWhereChain) }
+    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+    def where(*args); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def with(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def with_recursive(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+    def without(*args, &blk); end
+  end
+
+  module GeneratedRelationMethods
+    sig { returns(PrivateRelation) }
+    def all; end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def and(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def annotate(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def arel_columns(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def create_with(*args, &blk); end
+
+    sig { params(value: T::Boolean).returns(PrivateRelation) }
+    def distinct(value = true); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def eager_load(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def except(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def excluding(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def extending(*args, &blk); end
+
+    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+    def extract_associated(association); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def from(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationGroupChain) }
+    def group(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def having(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def in_order_of(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def includes(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def invert_where(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def left_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def left_outer_joins(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def limit(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def lock(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def merge(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def none(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def null_relation?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def offset(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def only(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def optimizer_hints(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def or(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def preload(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def readonly(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def references(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def regroup(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def reorder(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def reselect(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def reverse_order(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def rewhere(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def select(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def strict_loading(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def structurally_compatible?(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def uniq!(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def unscope(*args, &blk); end
+
+    sig { returns(PrivateRelationWhereChain) }
+    sig { params(args: T.untyped).returns(PrivateRelation) }
+    def where(*args); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def with(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def with_recursive(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+    def without(*args, &blk); end
+  end
+
+  class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation
+    include CommonRelationMethods
+    include GeneratedAssociationRelationMethods
+
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Fa::NodeBase } }
+
+    sig { returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def to_a; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def to_ary; end
+  end
+
+  class PrivateAssociationRelationGroupChain < PrivateAssociationRelation
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Fa::NodeBase } }
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+    def average(column_name); end
+
+    sig do
+      params(
+        operation: Symbol,
+        column_name: T.any(String, Symbol)
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def calculate(operation, column_name); end
+
+    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+    def count(column_name = nil); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+    def having(*args, &blk); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def maximum(column_name); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def minimum(column_name); end
+
+    sig do
+      params(
+        column_name: T.nilable(T.any(String, Symbol)),
+        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def sum(column_name = nil, &block); end
+  end
+
+  class PrivateAssociationRelationWhereChain
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Fa::NodeBase } }
+
+    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+    def associated(*args); end
+
+    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+    def missing(*args); end
+
+    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) }
+    def not(opts, *rest); end
+  end
+
+  class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy
+    include CommonRelationMethods
+    include GeneratedAssociationRelationMethods
+
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Fa::NodeBase } }
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[::ReduxGraph::Node::Fa::NodeBase])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def <<(*records); end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[::ReduxGraph::Node::Fa::NodeBase])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def append(*records); end
+
+    sig { returns(PrivateCollectionProxy) }
+    def clear; end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[::ReduxGraph::Node::Fa::NodeBase])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def concat(*records); end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def load_target; end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[::ReduxGraph::Node::Fa::NodeBase])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def prepend(*records); end
+
+    sig do
+      params(
+        records: T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[::ReduxGraph::Node::Fa::NodeBase])])
+      ).returns(PrivateCollectionProxy)
+    end
+    def push(*records); end
+
+    sig do
+      params(
+        other_array: T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[T.any(::ReduxGraph::Node::Fa::NodeBase, T::Enumerable[::ReduxGraph::Node::Fa::NodeBase])])
+      ).returns(T::Array[::ReduxGraph::Node::Fa::NodeBase])
+    end
+    def replace(other_array); end
+
+    sig { returns(PrivateAssociationRelation) }
+    def scope; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def target; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def to_a; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def to_ary; end
+  end
+
+  class PrivateRelation < ::ActiveRecord::Relation
+    include CommonRelationMethods
+    include GeneratedRelationMethods
+
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Fa::NodeBase } }
+
+    sig { returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def to_a; end
+
+    sig { returns(T::Array[::ReduxGraph::Node::Fa::NodeBase]) }
+    def to_ary; end
+  end
+
+  class PrivateRelationGroupChain < PrivateRelation
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Fa::NodeBase } }
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+    def average(column_name); end
+
+    sig do
+      params(
+        operation: Symbol,
+        column_name: T.any(String, Symbol)
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def calculate(operation, column_name); end
+
+    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+    def count(column_name = nil); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+    def having(*args, &blk); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def maximum(column_name); end
+
+    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def minimum(column_name); end
+
+    sig do
+      params(
+        column_name: T.nilable(T.any(String, Symbol)),
+        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def sum(column_name = nil, &block); end
+  end
+
+  class PrivateRelationWhereChain
+    Elem = type_member { { fixed: ::ReduxGraph::Node::Fa::NodeBase } }
+
+    sig { params(args: T.untyped).returns(PrivateRelation) }
+    def associated(*args); end
+
+    sig { params(args: T.untyped).returns(PrivateRelation) }
+    def missing(*args); end
+
+    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) }
+    def not(opts, *rest); end
+  end
+end

sorbet/rbi/gems/ffi-compiler@1.3.2.rbi

@@ -0,0 +1,185 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ffi-compiler` gem.
+# Please instead update this file by running `bin/tapioca gem ffi-compiler`.
+
+
+# source://ffi-compiler//lib/ffi-compiler/loader.rb#5
+module FFI
+  private
+
+  def custom_typedefs; end
+
+  class << self
+    def _async_cb_dispatcher_atfork_child; end
+
+    # source://ffi/1.17.1/lib/ffi/types.rb#62
+    def add_typedef(old, add); end
+
+    # source://ffi/1.17.1/lib/ffi/errno.rb#34
+    def errno; end
+
+    # source://ffi/1.17.1/lib/ffi/errno.rb#40
+    def errno=(error); end
+
+    # @raise [TypeError]
+    #
+    # source://ffi/1.17.1/lib/ffi/types.rb#76
+    def find_type(name, type_map = T.unsafe(nil)); end
+
+    # source://ffi/1.17.1/lib/ffi/compat.rb#35
+    def make_shareable(obj); end
+
+    # source://ffi/1.17.1/lib/ffi/library.rb#46
+    def map_library_name(lib); end
+
+    # source://ffi/1.17.1/lib/ffi/types.rb#101
+    def type_size(type); end
+
+    # source://ffi/1.17.1/lib/ffi/types.rb#56
+    def typedef(old, add); end
+
+    private
+
+    # source://ffi/1.17.1/lib/ffi/types.rb#66
+    def __typedef(old, add); end
+
+    def custom_typedefs; end
+  end
+end
+
+class FFI::ArrayType < ::FFI::Type
+  def initialize(_arg0, _arg1); end
+
+  def elem_type; end
+  def length; end
+end
+
+class FFI::Buffer < ::FFI::AbstractMemory
+  def initialize(*_arg0); end
+
+  def +(_arg0); end
+  def inspect; end
+  def length; end
+  def order(*_arg0); end
+  def slice(_arg0, _arg1); end
+
+  private
+
+  def initialize_copy(_arg0); end
+
+  class << self
+    def alloc_in(*_arg0); end
+    def alloc_inout(*_arg0); end
+    def alloc_out(*_arg0); end
+    def new_in(*_arg0); end
+    def new_inout(*_arg0); end
+    def new_out(*_arg0); end
+  end
+end
+
+# source://ffi-compiler//lib/ffi-compiler/platform.rb#1
+module FFI::Compiler; end
+
+# source://ffi-compiler//lib/ffi-compiler/loader.rb#7
+module FFI::Compiler::Loader
+  class << self
+    # source://ffi-compiler//lib/ffi-compiler/loader.rb#28
+    def caller_path(line = T.unsafe(nil)); end
+
+    # @raise [LoadError]
+    #
+    # source://ffi-compiler//lib/ffi-compiler/loader.rb#8
+    def find(name, start_path = T.unsafe(nil)); end
+  end
+end
+
+# source://ffi-compiler//lib/ffi-compiler/platform.rb#2
+class FFI::Compiler::Platform
+  # source://ffi-compiler//lib/ffi-compiler/platform.rb#13
+  def arch; end
+
+  # @return [Boolean]
+  #
+  # source://ffi-compiler//lib/ffi-compiler/platform.rb#25
+  def mac?; end
+
+  # source://ffi-compiler//lib/ffi-compiler/platform.rb#9
+  def map_library_name(name); end
+
+  # source://ffi-compiler//lib/ffi-compiler/platform.rb#21
+  def name; end
+
+  # source://ffi-compiler//lib/ffi-compiler/platform.rb#17
+  def os; end
+
+  class << self
+    # source://ffi-compiler//lib/ffi-compiler/platform.rb#5
+    def system; end
+  end
+end
+
+# source://ffi-compiler//lib/ffi-compiler/platform.rb#3
+FFI::Compiler::Platform::LIBSUFFIX = T.let(T.unsafe(nil), String)
+
+class FFI::FunctionType < ::FFI::Type
+  def initialize(*_arg0); end
+
+  def param_types; end
+  def return_type; end
+end
+
+module FFI::LastError
+  private
+
+  def error; end
+  def error=(_arg0); end
+
+  class << self
+    def error; end
+    def error=(_arg0); end
+  end
+end
+
+class FFI::MemoryPointer < ::FFI::Pointer
+  def initialize(*_arg0); end
+
+  class << self
+    def from_string(_arg0); end
+  end
+end
+
+module FFI::NativeType; end
+class FFI::NullPointerError < ::RuntimeError; end
+
+class FFI::StructByValue < ::FFI::Type
+  # @return [StructByValue] a new instance of StructByValue
+  def initialize(_arg0); end
+
+  def layout; end
+  def struct_class; end
+end
+
+class FFI::Type
+  # @return [Type] a new instance of Type
+  def initialize(_arg0); end
+
+  def alignment; end
+  def inspect; end
+  def size; end
+end
+
+class FFI::Type::Builtin < ::FFI::Type
+  def inspect; end
+end
+
+class FFI::Type::Mapped < ::FFI::Type
+  def initialize(_arg0); end
+
+  def converter; end
+  def from_native(*_arg0); end
+  def native_type; end
+  def to_native(*_arg0); end
+  def type; end
+end

sorbet/rbi/gems/http-form_data@2.3.0.rbi

@@ -0,0 +1,435 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `http-form_data` gem.
+# Please instead update this file by running `bin/tapioca gem http-form_data`.
+
+
+# http gem namespace.
+#
+# @see https://github.com/httprb/http
+#
+# source://http-form_data//lib/http/form_data/readable.rb#3
+module HTTP
+  class << self
+    # source://http/5.2.0/lib/http/chainable.rb#182
+    def [](headers); end
+  end
+end
+
+# Utility-belt to build form data request bodies.
+# Provides support for `application/x-www-form-urlencoded` and
+# `multipart/form-data` types.
+#
+# @example Usage
+#
+#   form = FormData.create({
+#   :username     => "ixti",
+#   :avatar_file  => FormData::File.new("/home/ixti/avatar.png")
+#   })
+#
+#   # Assuming socket is an open socket to some HTTP server
+#   socket << "POST /some-url HTTP/1.1\r\n"
+#   socket << "Host: example.com\r\n"
+#   socket << "Content-Type: #{form.content_type}\r\n"
+#   socket << "Content-Length: #{form.content_length}\r\n"
+#   socket << "\r\n"
+#   socket << form.to_s
+#
+# source://http-form_data//lib/http/form_data/readable.rb#4
+module HTTP::FormData
+  class << self
+    # FormData factory. Automatically selects best type depending on given
+    # `data` Hash.
+    #
+    # @param data [#to_h, Hash]
+    # @return [Multipart] if any of values is a {FormData::File}
+    # @return [Urlencoded] otherwise
+    #
+    # source://http-form_data//lib/http/form_data.rb#44
+    def create(data, encoder: T.unsafe(nil)); end
+
+    # Coerce `obj` to Hash.
+    #
+    # @note Internal usage helper, to workaround lack of `#to_h` on Ruby < 2.1
+    # @raise [Error] `obj` can't be coerced.
+    # @return [Hash]
+    #
+    # source://http-form_data//lib/http/form_data.rb#59
+    def ensure_hash(obj); end
+
+    private
+
+    # Tells whenever data contains multipart data or not.
+    #
+    # @param data [Hash]
+    # @return [Boolean]
+    #
+    # source://http-form_data//lib/http/form_data.rb#74
+    def multipart?(data); end
+  end
+end
+
+# CRLF
+#
+# source://http-form_data//lib/http/form_data.rb#32
+HTTP::FormData::CRLF = T.let(T.unsafe(nil), String)
+
+# Provides IO interface across multiple IO objects.
+#
+# source://http-form_data//lib/http/form_data/composite_io.rb#8
+class HTTP::FormData::CompositeIO
+  # @param ios [Array<IO>] Array of IO objects
+  # @return [CompositeIO] a new instance of CompositeIO
+  #
+  # source://http-form_data//lib/http/form_data/composite_io.rb#10
+  def initialize(ios); end
+
+  # Reads and returns partial content acrosss multiple IO objects.
+  #
+  # @param length [Integer] Number of bytes to retrieve
+  # @param outbuf [String] String to be replaced with retrieved data
+  # @return [String, nil]
+  #
+  # source://http-form_data//lib/http/form_data/composite_io.rb#31
+  def read(length = T.unsafe(nil), outbuf = T.unsafe(nil)); end
+
+  # Rewinds all IO objects and set cursor to the first IO object.
+  #
+  # source://http-form_data//lib/http/form_data/composite_io.rb#46
+  def rewind; end
+
+  # Returns sum of all IO sizes.
+  #
+  # source://http-form_data//lib/http/form_data/composite_io.rb#41
+  def size; end
+
+  private
+
+  # Advances cursor to the next IO object.
+  #
+  # source://http-form_data//lib/http/form_data/composite_io.rb#83
+  def advance_io; end
+
+  # Returns IO object under the cursor.
+  #
+  # source://http-form_data//lib/http/form_data/composite_io.rb#78
+  def current_io; end
+
+  # Yields chunks with total length up to `length`.
+  #
+  # source://http-form_data//lib/http/form_data/composite_io.rb#54
+  def read_chunks(length = T.unsafe(nil)); end
+
+  # Reads chunk from current IO with length up to `max_length`.
+  #
+  # source://http-form_data//lib/http/form_data/composite_io.rb#67
+  def readpartial(max_length = T.unsafe(nil)); end
+end
+
+# Generic FormData error.
+#
+# source://http-form_data//lib/http/form_data.rb#35
+class HTTP::FormData::Error < ::StandardError; end
+
+# Represents file form param.
+#
+# @example Usage with StringIO
+#
+#   io = StringIO.new "foo bar baz"
+#   FormData::File.new io, :filename => "foobar.txt"
+# @example Usage with IO
+#
+#   File.open "/home/ixti/avatar.png" do |io|
+#   FormData::File.new io
+#   end
+# @example Usage with pathname
+#
+#   FormData::File.new "/home/ixti/avatar.png"
+#
+# source://http-form_data//lib/http/form_data/file.rb#21
+class HTTP::FormData::File < ::HTTP::FormData::Part
+  # @option opts
+  # @option opts
+  # @param path_or_io [String, Pathname, IO] Filename or IO instance.
+  # @param opts [#to_h]
+  # @return [File] a new instance of File
+  # @see DEFAULT_MIME
+  #
+  # source://http-form_data//lib/http/form_data/file.rb#36
+  def initialize(path_or_io, opts = T.unsafe(nil)); end
+
+  # @deprecated Use #content_type instead
+  #
+  # source://http-form_data//lib/http/form_data/part.rb#18
+  def mime_type; end
+
+  private
+
+  # source://http-form_data//lib/http/form_data/file.rb#61
+  def filename_for(io); end
+
+  # source://http-form_data//lib/http/form_data/file.rb#51
+  def make_io(path_or_io); end
+end
+
+# Default MIME type
+#
+# source://http-form_data//lib/http/form_data/file.rb#23
+HTTP::FormData::File::DEFAULT_MIME = T.let(T.unsafe(nil), String)
+
+# `multipart/form-data` form data.
+#
+# source://http-form_data//lib/http/form_data/multipart/param.rb#8
+class HTTP::FormData::Multipart
+  include ::HTTP::FormData::Readable
+
+  # @param data [#to_h, Hash] form data key-value Hash
+  # @return [Multipart] a new instance of Multipart
+  #
+  # source://http-form_data//lib/http/form_data/multipart.rb#18
+  def initialize(data, boundary: T.unsafe(nil)); end
+
+  # Returns the value of attribute boundary.
+  #
+  # source://http-form_data//lib/http/form_data/multipart.rb#15
+  def boundary; end
+
+  # Returns form data content size to be used for HTTP request
+  # `Content-Length` header.
+  #
+  # @return [Integer]
+  #
+  # source://http-form_data//lib/http/form_data/readable.rb#30
+  def content_length; end
+
+  # Returns MIME type to be used for HTTP request `Content-Type` header.
+  #
+  # @return [String]
+  #
+  # source://http-form_data//lib/http/form_data/multipart.rb#36
+  def content_type; end
+
+  private
+
+  # @return [String]
+  #
+  # source://http-form_data//lib/http/form_data/multipart.rb#49
+  def glue; end
+
+  # @return [String]
+  #
+  # source://http-form_data//lib/http/form_data/multipart.rb#54
+  def tail; end
+
+  class << self
+    # Generates a string suitable for using as a boundary in multipart form
+    # data.
+    #
+    # @return [String]
+    #
+    # source://http-form_data//lib/http/form_data/multipart.rb#29
+    def generate_boundary; end
+  end
+end
+
+# Utility class to represent multi-part chunks
+#
+# source://http-form_data//lib/http/form_data/multipart/param.rb#10
+class HTTP::FormData::Multipart::Param
+  include ::HTTP::FormData::Readable
+
+  # Initializes body part with headers and data.
+  #
+  # @example With {FormData::File} value
+  #
+  #   Content-Disposition: form-data; name="avatar"; filename="avatar.png"
+  #   Content-Type: application/octet-stream
+  #
+  #   ...data of avatar.png...
+  # @example With non-{FormData::File} value
+  #
+  #   Content-Disposition: form-data; name="username"
+  #
+  #   ixti
+  # @param name [#to_s]
+  # @param value [FormData::File, FormData::Part, #to_s]
+  # @return [String]
+  #
+  # source://http-form_data//lib/http/form_data/multipart/param.rb#31
+  def initialize(name, value); end
+
+  private
+
+  # source://http-form_data//lib/http/form_data/multipart/param.rb#78
+  def content_type; end
+
+  # source://http-form_data//lib/http/form_data/multipart/param.rb#82
+  def filename; end
+
+  # source://http-form_data//lib/http/form_data/multipart/param.rb#86
+  def footer; end
+
+  # source://http-form_data//lib/http/form_data/multipart/param.rb#64
+  def header; end
+
+  # source://http-form_data//lib/http/form_data/multipart/param.rb#72
+  def parameters; end
+
+  class << self
+    # Flattens given `data` Hash into an array of `Param`'s.
+    # Nested array are unwinded.
+    # Behavior is similar to `URL.encode_www_form`.
+    #
+    # @param data [Hash]
+    # @return [Array<FormData::MultiPart::Param>]
+    #
+    # source://http-form_data//lib/http/form_data/multipart/param.rb#50
+    def coerce(data); end
+  end
+end
+
+# Represents a body part of multipart/form-data request.
+#
+# @example Usage with String
+#
+#   body = "Message"
+#   FormData::Part.new body, :content_type => 'foobar.txt; charset="UTF-8"'
+#
+# source://http-form_data//lib/http/form_data/part.rb#15
+class HTTP::FormData::Part
+  include ::HTTP::FormData::Readable
+
+  # @param body [#to_s]
+  # @param content_type [String] Value of Content-Type header
+  # @param filename [String] Value of filename parameter
+  # @return [Part] a new instance of Part
+  #
+  # source://http-form_data//lib/http/form_data/part.rb#23
+  def initialize(body, content_type: T.unsafe(nil), filename: T.unsafe(nil)); end
+
+  # Returns the value of attribute content_type.
+  #
+  # source://http-form_data//lib/http/form_data/part.rb#18
+  def content_type; end
+
+  # Returns the value of attribute filename.
+  #
+  # source://http-form_data//lib/http/form_data/part.rb#18
+  def filename; end
+end
+
+# Common behaviour for objects defined by an IO object.
+#
+# source://http-form_data//lib/http/form_data/readable.rb#6
+module HTTP::FormData::Readable
+  # Reads and returns part of IO content.
+  #
+  # @param length [Integer] Number of bytes to retrieve
+  # @param outbuf [String] String to be replaced with retrieved data
+  # @return [String, nil]
+  #
+  # source://http-form_data//lib/http/form_data/readable.rb#23
+  def read(length = T.unsafe(nil), outbuf = T.unsafe(nil)); end
+
+  # Rewinds the IO.
+  #
+  # source://http-form_data//lib/http/form_data/readable.rb#35
+  def rewind; end
+
+  # Returns IO size.
+  #
+  # @return [Integer]
+  #
+  # source://http-form_data//lib/http/form_data/readable.rb#30
+  def size; end
+
+  # Returns IO content.
+  #
+  # @return [String]
+  #
+  # source://http-form_data//lib/http/form_data/readable.rb#10
+  def to_s; end
+end
+
+# `application/x-www-form-urlencoded` form data.
+#
+# source://http-form_data//lib/http/form_data/urlencoded.rb#11
+class HTTP::FormData::Urlencoded
+  include ::HTTP::FormData::Readable
+
+  # @param data [#to_h, Hash] form data key-value Hash
+  # @return [Urlencoded] a new instance of Urlencoded
+  #
+  # source://http-form_data//lib/http/form_data/urlencoded.rb#66
+  def initialize(data, encoder: T.unsafe(nil)); end
+
+  # Returns form data content size to be used for HTTP request
+  # `Content-Length` header.
+  #
+  # @return [Integer]
+  #
+  # source://http-form_data//lib/http/form_data/readable.rb#30
+  def content_length; end
+
+  # Returns MIME type to be used for HTTP request `Content-Type` header.
+  #
+  # @return [String]
+  #
+  # source://http-form_data//lib/http/form_data/urlencoded.rb#74
+  def content_type; end
+
+  class << self
+    # Returns form data encoder implementation.
+    # Default: `URI.encode_www_form`.
+    #
+    # @return [#call]
+    # @see .encoder=
+    #
+    # source://http-form_data//lib/http/form_data/urlencoded.rb#60
+    def encoder; end
+
+    # Set custom form data encoder implementation.
+    #
+    # @example
+    #
+    #   module CustomFormDataEncoder
+    #   UNESCAPED_CHARS = /[^a-z0-9\-\.\_\~]/i
+    #
+    #   def self.escape(s)
+    #   ::URI::DEFAULT_PARSER.escape(s.to_s, UNESCAPED_CHARS)
+    #   end
+    #
+    #   def self.call(data)
+    #   parts = []
+    #
+    #   data.each do |k, v|
+    #   k = escape(k)
+    #
+    #   if v.nil?
+    #   parts << k
+    #   elsif v.respond_to?(:to_ary)
+    #   v.to_ary.each { |vv| parts << "#{k}=#{escape vv}" }
+    #   else
+    #   parts << "#{k}=#{escape v}"
+    #   end
+    #   end
+    #
+    #   parts.join("&")
+    #   end
+    #   end
+    #
+    #   HTTP::FormData::Urlencoded.encoder = CustomFormDataEncoder
+    # @param implementation [#call]
+    # @raise [ArgumentError] if implementation deos not responds to `#call`.
+    # @return [void]
+    #
+    # source://http-form_data//lib/http/form_data/urlencoded.rb#50
+    def encoder=(implementation); end
+  end
+end
+
+# Gem version.
+#
+# source://http-form_data//lib/http/form_data/version.rb#6
+HTTP::FormData::VERSION = T.let(T.unsafe(nil), String)

sorbet/rbi/gems/llhttp-ffi@0.5.0.rbi

@@ -0,0 +1,275 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `llhttp-ffi` gem.
+# Please instead update this file by running `bin/tapioca gem llhttp-ffi`.
+
+
+# source://llhttp-ffi//lib/llhttp.rb#6
+module LLHttp
+  extend ::FFI::Library
+
+  def llhttp_errno_name(*_arg0); end
+  def llhttp_execute(*_arg0); end
+  def llhttp_finish(*_arg0); end
+  def llhttp_get_error_reason(*_arg0); end
+  def llhttp_reset(*_arg0); end
+  def llhttp_should_keep_alive(*_arg0); end
+  def rb_llhttp_content_length(*_arg0); end
+  def rb_llhttp_free(*_arg0); end
+  def rb_llhttp_http_major(*_arg0); end
+  def rb_llhttp_http_minor(*_arg0); end
+  def rb_llhttp_init(*_arg0); end
+  def rb_llhttp_method_name(*_arg0); end
+  def rb_llhttp_status_code(*_arg0); end
+
+  class << self
+    def llhttp_errno_name(*_arg0); end
+    def llhttp_execute(*_arg0); end
+    def llhttp_finish(*_arg0); end
+    def llhttp_get_error_reason(*_arg0); end
+    def llhttp_reset(*_arg0); end
+    def llhttp_should_keep_alive(*_arg0); end
+    def rb_llhttp_content_length(*_arg0); end
+    def rb_llhttp_free(*_arg0); end
+    def rb_llhttp_http_major(*_arg0); end
+    def rb_llhttp_http_minor(*_arg0); end
+    def rb_llhttp_init(*_arg0); end
+    def rb_llhttp_method_name(*_arg0); end
+    def rb_llhttp_status_code(*_arg0); end
+
+    # [public] LLHttp's current version.
+    #
+    # source://llhttp-ffi//lib/llhttp/version.rb#8
+    def version; end
+  end
+end
+
+# source://llhttp-ffi//lib/llhttp.rb#18
+class LLHttp::Callbacks < ::FFI::Struct; end
+
+# [public] Delegate for handling callbacks. Subclass this object and implement necessary methods.
+#
+#   class Delegate < LLHttp::Delegate
+#     def on_message_begin
+#       ...
+#     end
+#
+#     def on_url(url)
+#       ...
+#     end
+#
+#     def on_status(status)
+#       ...
+#     end
+#
+#     def on_header_field(field)
+#       ...
+#     end
+#
+#     def on_header_value(value)
+#       ...
+#     end
+#
+#     def on_headers_complete
+#       ...
+#     end
+#
+#     def on_body(body)
+#       ...
+#     end
+#
+#     def on_message_complete
+#       ...
+#     end
+#
+#     def on_chunk_header
+#       ...
+#     end
+#
+#     def on_chunk_complete
+#       ...
+#     end
+#
+#     def on_url_complete
+#       ...
+#     end
+#
+#     def on_status_complete
+#       ...
+#     end
+#
+#     def on_header_field_complete
+#       ...
+#     end
+#
+#     def on_header_value_complete
+#       ...
+#     end
+#   end
+#
+# source://llhttp-ffi//lib/llhttp/delegate.rb#64
+class LLHttp::Delegate; end
+
+# [public] LLHttp's standard error object.
+#
+# source://llhttp-ffi//lib/llhttp/error.rb#6
+class LLHttp::Error < ::StandardError; end
+
+# [public] Wraps an llhttp context for parsing http requests and responses.
+#
+#   class Delegate < LLHttp::Delegate
+#     def on_message_begin
+#       ...
+#     end
+#
+#     ...
+#   end
+#
+#   parser = LLHttp::Parser.new(Delegate.new, type: :request)
+#   parser << "GET / HTTP/1.1\r\n\r\n"
+#   parser.finish
+#
+#   ...
+#
+# Introspection
+#
+#   * `LLHttp::Parser#content_length` returns the content length of the current request.
+#   * `LLHttp::Parser#method_name` returns the method name of the current response.
+#   * `LLHttp::Parser#status_code` returns the status code of the current response.
+#   * `LLHttp::Parser#http_major` returns the major http version of the current request/response.
+#   * `LLHttp::Parser#http_minor` returns the minor http version of the current request/response.
+#   * `LLHttp::Parser#keep_alive?` returns `true` if there might be more messages.
+#
+# Finishing
+#
+#   Call `LLHttp::Parser#finish` when processing is complete for the current request or response.
+#
+# source://llhttp-ffi//lib/llhttp/parser.rb#33
+class LLHttp::Parser
+  # @return [Parser] a new instance of Parser
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#60
+  def initialize(delegate, type: T.unsafe(nil)); end
+
+  # [public] Parse the given data.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#78
+  def <<(data); end
+
+  # [public] Get the content length of the current request.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#86
+  def content_length; end
+
+  # [public] Tells the parser we are finished.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#122
+  def finish; end
+
+  # [public] Get the major http version of the current request/response.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#104
+  def http_major; end
+
+  # [public] Get the minor http version of the current request/response.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#110
+  def http_minor; end
+
+  # [public] Returns `true` if there might be more messages.
+  #
+  # @return [Boolean]
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#116
+  def keep_alive?; end
+
+  # [public] Get the method of the current response.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#92
+  def method_name; end
+
+  # [public] Parse the given data.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#78
+  def parse(data); end
+
+  # [public] Get ready to parse the next request/response.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#128
+  def reset; end
+
+  # [public] Get the status code of the current response.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#98
+  def status_code; end
+
+  # [public] The parser type; one of: `:both`, `:request`, or `:response`.
+  #
+  # source://llhttp-ffi//lib/llhttp/parser.rb#58
+  def type; end
+
+  private
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#156
+  def build_error(errno); end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#149
+  def on_body(buffer, length); end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#135
+  def on_chunk_complete; end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#135
+  def on_chunk_header; end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#149
+  def on_header_field(buffer, length); end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#135
+  def on_header_field_complete; end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#149
+  def on_header_value(buffer, length); end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#135
+  def on_header_value_complete; end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#135
+  def on_headers_complete; end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#135
+  def on_message_begin; end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#135
+  def on_message_complete; end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#149
+  def on_status(buffer, length); end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#135
+  def on_status_complete; end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#149
+  def on_url(buffer, length); end
+
+  # source://llhttp-ffi//lib/llhttp/parser.rb#135
+  def on_url_complete; end
+
+  class << self
+    # source://llhttp-ffi//lib/llhttp/parser.rb#160
+    def free(pointer); end
+  end
+end
+
+# source://llhttp-ffi//lib/llhttp/parser.rb#36
+LLHttp::Parser::CALLBACKS = T.let(T.unsafe(nil), Array)
+
+# source://llhttp-ffi//lib/llhttp/parser.rb#48
+LLHttp::Parser::CALLBACKS_WITH_DATA = T.let(T.unsafe(nil), Array)
+
+# source://llhttp-ffi//lib/llhttp/parser.rb#34
+LLHttp::Parser::LLHTTP_TYPES = T.let(T.unsafe(nil), Hash)
+
+# source://llhttp-ffi//lib/llhttp/version.rb#4
+LLHttp::VERSION = T.let(T.unsafe(nil), String)

sorbet/rbi/shims/activerecord_migration.rbi

@@ -0,0 +1,12 @@
+# typed: strict
+class ActiveRecord::Migration
+  extend T::Sig
+
+  sig { params(name: T.any(Symbol, String), values: T::Array[String]).void }
+  def create_enum(name, values)
+  end
+
+  sig { params(name: T.any(Symbol, String)).void }
+  def drop_enum(name)
+  end
+end

sorbet/tapioca/compilers/active_record_fixups.rb

@@ -0,0 +1,3 @@
+# typed: strict
+# make all the graph classes concrete
+Graph::Base.descendants.each { |klass| klass.abstract_class = false }

sorbet/tapioca/require.rb

@@ -1,7 +1,14 @@
 # typed: true
 # frozen_string_literal: true
 
+require "./app/models/graph/node/belongs_to_node_assoc"
+require "./app/models/graph/node/has_one_node_assoc"
+require "./app/models/graph/node/has_many_nodes_assoc"
+require "./spec/lib/graph/nodes_for_tests"
 require "./app/lib/has_color_logger"
+require "./app/lib/graph/base"
+require "./app/lib/graph/edge"
+require "./app/lib/graph/node"
 require "./spec/helpers/debug_helpers"
 require "./spec/helpers/http_client_mock_helpers"
 require "./spec/helpers/perform_job_helpers"

spec/factories/regius_graph/nodes/common.rb

@@ -0,0 +1,7 @@
+FactoryBot.define do
+  factory :graph_content_description,
+          class: ReduxGraph::Node::Common::ContentDescription do
+    sequence(:id) { |n| n }
+    sequence(:content) { |n| "Description of the content #{n}" }
+  end
+end

spec/factories/regius_graph/nodes/fa.rb

@@ -0,0 +1,21 @@
+# typed: false
+
+FactoryBot.define do
+  factory :graph_fa_user, class: "ReduxGraph::Node::Fa::User" do
+    sequence(:id) { |n| n }
+    sequence(:url_name) { |n| "john_doe_#{n}" }
+    sequence(:name) { |n| "JohnDoe_#{n}" }
+  end
+
+  factory :graph_fa_post, class: "ReduxGraph::Node::Fa::Post" do
+    sequence(:id) { |n| n }
+    sequence(:title) { |n| "Post #{n}" }
+    category { "All" }
+    theme { "General Furry Art" }
+    species { "Unspecified / Any" }
+    gender { "Any" }
+    association :description, factory: :graph_content_description
+    keywords { %w[keyword1 keyword2] }
+    creator { create(:graph_fa_user) }
+  end
+end

spec/models/redux_graph/node/fa_spec.rb

@@ -0,0 +1,51 @@
+require "rails_helper"
+
+describe ReduxGraph::Node::Fa::NodeBase do
+  describe "users" do
+    it "has a working factory" do
+      user =
+        create(:graph_fa_user, id: "1", url_name: "john_doe", name: "JohnDoe")
+      expect(user.id).to eq(1)
+      expect(user.url_name).to eq("john_doe")
+      expect(user.name).to eq("JohnDoe")
+    end
+
+    it "can have posts" do
+      user =
+        ReduxGraph::Node::Fa::User.create!(
+          id: "1",
+          url_name: "john_doe",
+          name: "JohnDoe",
+        )
+      post = ReduxGraph::Node::Fa::Post.create!(id: "1", title: "My First Post")
+
+      user.posts << post
+      expect(user.posts.count).to eq(1)
+      expect(post.creator).to eq(user)
+
+      # bulk loading
+      puts "bulk loading start"
+      user = ReduxGraph::Node::Fa::User.includes(:posts).find(1)
+    end
+
+    it "can have favorites" do
+      user = create(:graph_fa_user, id: 1)
+      post = create(:graph_fa_post, id: 1, creator: user)
+      user.favorites << post
+      expect(user.favorites.count).to eq(1)
+      expect(post.favorited_by.count).to eq(1)
+      expect(ReduxGraph::Edge::Common::UserHasFavorite.count).to eq(1)
+    end
+
+    it "can be queried by url_name" do
+      user1 = create(:graph_fa_user, url_name: "user1")
+      user2 = create(:graph_fa_user, url_name: "user2")
+
+      user = ReduxGraph::Node::Fa::User.find_by(url_name: "user1")
+      expect(user).to eq(user1)
+
+      user = ReduxGraph::Node::Fa::User.find_by(url_name: "user2")
+      expect(user).to eq(user2)
+    end
+  end
+end

spec/spec_helper.rb

@@ -19,6 +19,7 @@ require "./spec/helpers/debug_helpers"
 require "./spec/helpers/http_client_mock_helpers"
 require "./spec/support/matchers/html_matchers"
 require "./spec/support/matchers/job_matchers"
+require "./spec/support/matchers/object_id_matchers"
 require "rspec/sorbet"
 RSpec::Sorbet.allow_doubles!
 

spec/support/matchers/object_id_matchers.rb

@@ -0,0 +1,33 @@
+# typed: false
+RSpec::Matchers.define :eq_and_obj_id do |expected|
+  match do |actual|
+    actual == expected && actual.object_id == expected.object_id
+  end
+
+  failure_message do |actual|
+    if actual != expected
+      "expected #{actual.inspect} to be equal to #{expected.inspect}"
+    else
+      "expected #{actual.inspect} to have the same object_id (#{actual.object_id}) as #{expected.inspect} (#{expected.object_id})"
+    end
+  end
+
+  failure_message_when_negated do |actual|
+    if actual == expected
+      "expected #{actual.inspect} not to be equal to #{expected.inspect}"
+    else
+      "expected #{actual.inspect} not to have the same object_id (#{actual.object_id}) as #{expected.inspect} (#{expected.object_id})"
+    end
+  end
+end
+
+RSpec::Matchers.define :succeed_around do
+  match(notify_expectation_failures: true) do |actual|
+    actual.call
+    block_arg.call
+    actual.call
+    true
+  end
+
+  supports_block_expectations
+end