wal 0.0.0 → 0.0.2

data/rbi/wal.rbi

@@ -0,0 +1,295 @@
+# typed: strong
+module Wal
+  Event = T.type_alias { T.any(
+      BeginTransactionEvent,
+      CommitTransactionEvent,
+      InsertEvent,
+      UpdateEvent,
+      DeleteEvent,
+    ) }
+  VERSION = "0.0.2"
+
+  class BeginTransactionEvent < T::Struct
+    prop :transaction_id, Integer, immutable: true
+    prop :lsn, Integer, immutable: true
+    prop :final_lsn, Integer, immutable: true
+    prop :timestamp, Time, immutable: true
+
+    extend T::Sig
+
+    sig { returns(Integer) }
+    def estimated_size; end
+  end
+
+  class CommitTransactionEvent < T::Struct
+    prop :transaction_id, Integer, immutable: true
+    prop :lsn, Integer, immutable: true
+    prop :context, T::Hash[String, T.untyped], immutable: true
+    prop :timestamp, Time, immutable: true
+
+  end
+
+  module ChangeEvent
+    extend T::Sig
+
+    sig { returns(T::Hash[String, [T.untyped, T.untyped]]) }
+    def diff; end
+
+    sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+    def changed_attribute?(attribute); end
+
+    sig { params(attribute: T.any(Symbol, String)).returns(T.untyped) }
+    def attribute(attribute); end
+
+    sig { params(attribute: T.any(Symbol, String)).returns(T.nilable([T.untyped, T.untyped])) }
+    def attribute_changes(attribute); end
+
+    sig { params(attribute: T.any(Symbol, String)).returns(T.untyped) }
+    def attribute_was(attribute); end
+  end
+
+  class InsertEvent < T::Struct
+    prop :transaction_id, Integer, immutable: true
+    prop :lsn, Integer, immutable: true
+    prop :context, T::Hash[String, T.untyped], immutable: true
+    prop :table, String, immutable: true
+    prop :primary_key, T.untyped, immutable: true
+    prop :new, T::Hash[String, T.untyped], immutable: true
+
+    include ::Wal::ChangeEvent
+    extend T::Sig
+
+    sig { returns(T::Hash[String, [T.untyped, T.untyped]]) }
+    def diff; end
+  end
+
+  class UpdateEvent < T::Struct
+    prop :transaction_id, Integer, immutable: true
+    prop :lsn, Integer, immutable: true
+    prop :context, T::Hash[String, T.untyped], immutable: true
+    prop :table, String, immutable: true
+    prop :primary_key, T.untyped, immutable: true
+    prop :old, T::Hash[String, T.untyped], immutable: true
+    prop :new, T::Hash[String, T.untyped], immutable: true
+
+    include ::Wal::ChangeEvent
+    extend T::Sig
+
+    sig { returns(T::Hash[String, [T.untyped, T.untyped]]) }
+    def diff; end
+  end
+
+  class DeleteEvent < T::Struct
+    prop :transaction_id, Integer, immutable: true
+    prop :lsn, Integer, immutable: true
+    prop :context, T::Hash[String, T.untyped], immutable: true
+    prop :table, String, immutable: true
+    prop :primary_key, T.untyped, immutable: true
+    prop :old, T::Hash[String, T.untyped], immutable: true
+
+    include ::Wal::ChangeEvent
+    extend T::Sig
+
+    sig { returns(T::Hash[String, [T.untyped, T.untyped]]) }
+    def diff; end
+  end
+
+  module ActiveRecordContextExtension
+    sig { params(context: T.untyped, prefix: T.untyped).returns(T.untyped) }
+    def set_wal_watcher_context(context, prefix: ""); end
+  end
+
+  class NoopWatcher
+    include Wal::Watcher
+    extend T::Sig
+
+    sig { override.params(event: Event).void }
+    def on_event(event); end
+  end
+
+  class RecordWatcher
+    abstract!
+
+    include Wal::Watcher
+    extend T::Sig
+    extend T::Helpers
+    RecordEvent = T.type_alias { T.any(InsertEvent, UpdateEvent, DeleteEvent) }
+
+    sig { params(subclass: T.untyped).returns(T.untyped) }
+    def self.inherited(subclass); end
+
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), block: T.proc.bind(T.attached_class).params(event: InsertEvent).void).void }
+    def self.on_insert(table, &block); end
+
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), changed: T.nilable(T::Array[T.any(String, Symbol)]), block: T.proc.bind(T.attached_class).params(event: UpdateEvent).void).void }
+    def self.on_update(table, changed: nil, &block); end
+
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), changed: T.nilable(T::Array[T.any(String, Symbol)]), block: T.proc.bind(T.attached_class).params(event: T.any(InsertEvent, UpdateEvent)).void).void }
+    def self.on_save(table, changed: nil, &block); end
+
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), block: T.proc.bind(T.attached_class).params(event: DeleteEvent).void).void }
+    def self.on_destroy(table, &block); end
+
+    sig { params(event: RecordEvent).void }
+    def on_record_changed(event); end
+
+    sig { params(table: String).returns(T::Boolean) }
+    def should_watch_table?(table); end
+
+    sig { params(event: BeginTransactionEvent).returns(Symbol) }
+    def aggregation_strategy(event); end
+
+    sig { override.params(event: Event).void }
+    def on_event(event); end
+
+    class MemoryRecordWatcher
+      include Wal::Watcher
+      include Wal::Watcher::SeparatedEvents
+      extend T::Sig
+      extend T::Helpers
+      RecordsStorage = T.type_alias { T::Hash[[String, Integer], T.nilable(RecordEvent)] }
+
+      sig { params(watcher: T.untyped).void }
+      def initialize(watcher); end
+
+      sig { params(event: BeginTransactionEvent).void }
+      def on_begin(event); end
+
+      sig { params(_event: T.untyped).returns(T.untyped) }
+      def on_commit(_event); end
+
+      sig { params(event: InsertEvent).void }
+      def on_insert(event); end
+
+      sig { params(event: UpdateEvent).void }
+      def on_update(event); end
+
+      sig { params(event: DeleteEvent).void }
+      def on_delete(event); end
+    end
+
+    class TemporaryTableRecordWatcher
+      include Wal::Watcher
+      include Wal::Watcher::SeparatedEvents
+      extend T::Sig
+      extend T::Helpers
+
+      sig { params(watcher: T.untyped, batch_size: T.untyped).void }
+      def initialize(watcher, batch_size: 5_000); end
+
+      sig { params(event: BeginTransactionEvent).void }
+      def on_begin(event); end
+
+      sig { params(_event: T.untyped).returns(T.untyped) }
+      def on_commit(_event); end
+
+      sig { params(event: InsertEvent).void }
+      def on_insert(event); end
+
+      sig { params(event: UpdateEvent).void }
+      def on_update(event); end
+
+      sig { params(event: DeleteEvent).void }
+      def on_delete(event); end
+
+      sig { returns(T.class_of(::ActiveRecord::Base)) }
+      def base_class; end
+
+      sig { params(event: T.untyped).returns(T.untyped) }
+      def serialize(event); end
+
+      sig { params(persisted_event: T.untyped).returns(T.untyped) }
+      def deserialize(persisted_event); end
+    end
+  end
+
+  class Replicator
+    include PG::Replication::Protocol
+    extend T::Sig
+
+    sig { params(replication_slot: String, use_temporary_slot: T::Boolean, db_config: T::Hash[Symbol, T.untyped]).void }
+    def initialize(replication_slot:, use_temporary_slot: false, db_config: ActiveRecord::Base.configurations.configs_for(name: "primary").configuration_hash); end
+
+    sig { params(watcher: Watcher, publications: T::Array[String]).void }
+    def replicate_forever(watcher, publications:); end
+
+    sig { params(watcher: Watcher, publications: T::Array[String]).returns(T::Enumerator::Lazy[Event]) }
+    def replicate(watcher, publications:); end
+
+    class Column < T::Struct
+      prop :name, String, immutable: true
+      prop :decoder, T.untyped, immutable: true
+
+      sig { params(value: T.untyped).returns(T.untyped) }
+      def decode(value); end
+    end
+
+    class Table < T::Struct
+      prop :name, String, immutable: true
+      prop :primary_key_colums, T::Array[String], immutable: true
+      prop :columns, T::Array[Column], immutable: true
+
+      sig { params(decoded_row: T.untyped).returns(T.untyped) }
+      def primary_key(decoded_row); end
+
+      sig { params(values: T.untyped).returns(T.untyped) }
+      def decode_row(values); end
+    end
+  end
+
+  class StreamingWatcher
+    abstract!
+
+    include Wal::Watcher
+    extend T::Sig
+    extend T::Helpers
+
+    sig { abstract.params(events: T::Enumerator[Event]).void }
+    def on_transaction_events(events); end
+
+    sig { params(event: BeginTransactionEvent).returns(Integer) }
+    def queue_size(event); end
+
+    sig { override.params(event: Event).void }
+    def on_event(event); end
+  end
+
+  module Watcher
+    abstract!
+
+    include Wal
+    extend T::Sig
+    extend T::Helpers
+
+    sig { abstract.params(event: Event).void }
+    def on_event(event); end
+
+    sig { params(table: String).returns(T::Boolean) }
+    def should_watch_table?(table); end
+
+    sig { params(prefix: String).returns(T::Boolean) }
+    def valid_context_prefix?(prefix); end
+
+    module SeparatedEvents
+      extend T::Sig
+
+      sig { params(event: Event).void }
+      def on_event(event); end
+
+      sig { params(event: BeginTransactionEvent).void }
+      def on_begin(event); end
+
+      sig { params(event: InsertEvent).void }
+      def on_insert(event); end
+
+      sig { params(event: UpdateEvent).void }
+      def on_update(event); end
+
+      sig { params(event: DeleteEvent).void }
+      def on_delete(event); end
+
+      sig { params(event: CommitTransactionEvent).void }
+      def on_commit(event); end
+    end
+  end
+end

data/sig/wal.rbs

@@ -1,4 +1,186 @@
+# typed: strong
 module Wal
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end
+
+Wal::Event: untyped
+
+Wal::VERSION: untyped
+
+class Wal::BeginTransactionEvent < T::Struct
+  def estimated_size: () -> Integer
+end
+
+class Wal::CommitTransactionEvent < T::Struct
+end
+
+module Wal::ChangeEvent
+  def diff: () -> ::Hash[String, [ untyped, untyped ]]
+
+  def changed_attribute?: (Symbol | String attribute) -> bool
+
+  def attribute: (Symbol | String attribute) -> untyped
+
+  def attribute_changes: (Symbol | String attribute) -> [ untyped, untyped ]?
+
+  def attribute_was: (Symbol | String attribute) -> untyped
+end
+
+class Wal::InsertEvent < T::Struct
+  include ::Wal::ChangeEvent
+
+  def diff: () -> ::Hash[String, [ untyped, untyped ]]
+end
+
+class Wal::UpdateEvent < T::Struct
+  include ::Wal::ChangeEvent
+
+  def diff: () -> ::Hash[String, [ untyped, untyped ]]
+end
+
+class Wal::DeleteEvent < T::Struct
+  include ::Wal::ChangeEvent
+
+  def diff: () -> ::Hash[String, [ untyped, untyped ]]
+end
+
+module Wal::ActiveRecordContextExtension
+  def set_wal_watcher_context: (untyped context, ?prefix: untyped prefix) -> untyped
+end
+
+class Wal::NoopWatcher
+  include Wal::Watcher
+
+  def on_event: (Event event) -> void
+end
+
+class Wal::RecordWatcher
+  include Wal::Watcher
+
+  extend T::Helpers
+
+  def self.inherited: (untyped subclass) -> untyped
+
+  def self.on_insert: (String | singleton(::ActiveRecord::Base) table) { (InsertEvent event) -> void } -> void
+
+  def self.on_update: (String | singleton(::ActiveRecord::Base) table, ?changed: ::Array[String | Symbol]? changed) { (UpdateEvent event) -> void } -> void
+
+  def self.on_save: (String | singleton(::ActiveRecord::Base) table, ?changed: ::Array[String | Symbol]? changed) { (InsertEvent | UpdateEvent event) -> void } -> void
+
+  def self.on_destroy: (String | singleton(::ActiveRecord::Base) table) { (DeleteEvent event) -> void } -> void
+
+  def on_record_changed: (RecordEvent event) -> void
+
+  def should_watch_table?: (String table) -> bool
+
+  def aggregation_strategy: (BeginTransactionEvent event) -> Symbol
+
+  def on_event: (Event event) -> void
+end
+
+Wal::Wal::RecordWatcher::RecordEvent: untyped
+
+class Wal::Wal::RecordWatcher::MemoryRecordWatcher
+  include Wal::Watcher
+
+  include Wal::Watcher::SeparatedEvents
+
+  extend T::Helpers
+
+  def initialize: (untyped watcher) -> void
+
+  def on_begin: (BeginTransactionEvent event) -> void
+
+  def on_commit: (untyped _event) -> untyped
+
+  def on_insert: (InsertEvent event) -> void
+
+  def on_update: (UpdateEvent event) -> void
+
+  def on_delete: (DeleteEvent event) -> void
+end
+
+Wal::Wal::RecordWatcher::Wal::Wal::RecordWatcher::MemoryRecordWatcher::RecordsStorage: untyped
+
+class Wal::Wal::RecordWatcher::TemporaryTableRecordWatcher
+  include Wal::Watcher
+
+  include Wal::Watcher::SeparatedEvents
+
+  extend T::Helpers
+
+  def initialize: (untyped watcher, ?batch_size: untyped batch_size) -> void
+
+  def on_begin: (BeginTransactionEvent event) -> void
+
+  def on_commit: (untyped _event) -> untyped
+
+  def on_insert: (InsertEvent event) -> void
+
+  def on_update: (UpdateEvent event) -> void
+
+  def on_delete: (DeleteEvent event) -> void
+
+  def base_class: () -> singleton(::ActiveRecord::Base)
+
+  def serialize: (untyped event) -> untyped
+
+  def deserialize: (untyped persisted_event) -> untyped
+end
+
+class Wal::Replicator
+  include PG::Replication::Protocol
+
+  def initialize: (?replication_slot: String replication_slot, ?use_temporary_slot: bool use_temporary_slot, ?db_config: ::Hash[Symbol, untyped] db_config) -> void
+
+  def replicate_forever: (Watcher watcher, ?publications: ::Array[String] publications) -> void
+
+  def replicate: (Watcher watcher, ?publications: ::Array[String] publications) -> ::Enumerator::Lazy[Event]
+end
+
+class Wal::Wal::Replicator::Column < T::Struct
+  def decode: (untyped value) -> untyped
+end
+
+class Wal::Wal::Replicator::Table < T::Struct
+  def primary_key: (untyped decoded_row) -> untyped
+
+  def decode_row: (untyped values) -> untyped
+end
+
+class Wal::StreamingWatcher
+  include Wal::Watcher
+
+  extend T::Helpers
+
+  def on_transaction_events: (::Enumerator[Event] events) -> void
+
+  def queue_size: (BeginTransactionEvent event) -> Integer
+
+  def on_event: (Event event) -> void
+end
+
+module Wal::Watcher
+  include Wal
+
+  extend T::Helpers
+
+  def on_event: (Event event) -> void
+
+  def should_watch_table?: (String table) -> bool
+
+  def valid_context_prefix?: (String prefix) -> bool
+end
+
+module Wal::Wal::Watcher::SeparatedEvents
+  def on_event: (Event event) -> void
+
+  def on_begin: (BeginTransactionEvent event) -> void
+
+  def on_insert: (InsertEvent event) -> void
+
+  def on_update: (UpdateEvent event) -> void
+
+  def on_delete: (DeleteEvent event) -> void
+
+  def on_commit: (CommitTransactionEvent event) -> void
 end

data/sorbet/config

@@ -0,0 +1,7 @@
+--dir
+.
+--ignore=tmp/
+--ignore=sig/
+--ignore=vendor/
+--suppress-payload-superclass-redefinition-for=Psych::Parser::Mark
+--suppress-payload-superclass-redefinition-for=IRB::ReadlineInputMethod

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/activemodel.rbi

@@ -0,0 +1,89 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActiveModel::Errors
+  Elem = type_member { { fixed: ActiveModel::Error } }
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def [](attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(ActiveModel::Error) }
+  def add(attribute, type = :invalid, **options); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Boolean) }
+  def added?(attribute, type = :invalid, options = {}); end
+
+  sig { params(options: T.untyped).returns(T::Hash[T.untyped, T.untyped]) }
+  def as_json(options = nil); end
+
+  sig { returns(T::Array[Symbol]) }
+  def attribute_names; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T.nilable(T::Array[String])) }
+  def delete(attribute, type = nil, **options); end
+
+  sig { returns(T::Hash[Symbol, T::Array[T::Hash[Symbol, T.untyped]]]) }
+  def details; end
+
+  sig { returns(T::Array[Elem]) }
+  def errors; end
+
+  sig { params(attribute: T.any(Symbol, String), message: String).returns(String) }
+  def full_message(attribute, message); end
+
+  sig { returns(T::Array[String]) }
+  def full_messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def full_messages_for(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(String) }
+  def generate_message(attribute, type = :invalid, options = {}); end
+
+  sig { returns(T::Hash[Symbol, T::Array[ActiveModel::Error]]) }
+  def group_by_attribute; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def has_key?(attribute); end
+
+  sig { params(error: ActiveModel::Error, override_options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def import(error, override_options = {}); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def include?(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def key?(attribute); end
+
+  sig { params(other: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def merge!(other); end
+
+  sig { returns(T::Hash[Symbol, T::Array[String]]) }
+  def messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def messages_for(attribute); end
+
+  sig { returns(T::Array[Elem]) }
+  def objects; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped).returns(T::Boolean) }
+  def of_kind?(attribute, type = :invalid); end
+
+  sig { returns(T::Array[String]) }
+  def to_a; end
+
+  sig { params(full_messages: T.untyped).returns(T::Hash[Symbol, T::Array[String]]) }
+  def to_hash(full_messages = false); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def where(attribute, type = nil, **options); end
+end
+
+module ActiveModel::Validations
+  sig { returns(ActiveModel::Errors) }
+  def errors; end
+end

data/sorbet/rbi/annotations/activerecord.rbi

@@ -0,0 +1,98 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActiveRecord::Schema
+  sig { params(info: T::Hash[T.untyped, T.untyped], blk: T.proc.bind(ActiveRecord::Schema).void).void }
+  def self.define(info = nil, &blk); end
+end
+
+class ActiveRecord::Migration
+  # @shim: Methods on migration are delegated to `SchemaStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::SchemaStatements
+
+  # @shim: Methods on migration are delegated to `DatabaseStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::DatabaseStatements
+end
+
+class ActiveRecord::Base
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  sig { returns(TrueClass) }
+  def present?; end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_initialize(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_find(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_touch(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_commit(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_rollback(*args, **options, &block); end
+end
+
+class ActiveRecord::Relation
+  Elem = type_member(:out) { { fixed: T.untyped } }
+
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  sig { abstract.params(blk: T.proc.params(arg0: Elem).returns(BasicObject)).returns(T.untyped) }
+  sig { abstract.returns(T::Enumerator[Elem]) }
+  def each(&blk); end
+end