wal 0.0.2 → 0.0.4

data/rbi/wal.rbi

@@ -7,7 +7,7 @@ module Wal
       UpdateEvent,
       DeleteEvent,
     ) }
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 
   class BeginTransactionEvent < T::Struct
     prop :transaction_id, Integer, immutable: true
@@ -103,7 +103,7 @@ module Wal
     include Wal::Watcher
     extend T::Sig
 
-    sig { override.params(event: Event).void }
+    sig { override.params(event: Wal::Event).void }
     def on_event(event); end
   end
 
@@ -113,21 +113,21 @@ module Wal
     include Wal::Watcher
     extend T::Sig
     extend T::Helpers
-    RecordEvent = T.type_alias { T.any(InsertEvent, UpdateEvent, DeleteEvent) }
+    RecordEvent = T.type_alias { T.any(Wal::InsertEvent, Wal::UpdateEvent, Wal::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 }
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), block: T.proc.bind(T.attached_class).params(event: Wal::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 }
+    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: Wal::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 }
+    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(Wal::InsertEvent, Wal::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 }
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), block: T.proc.bind(T.attached_class).params(event: Wal::DeleteEvent).void).void }
     def self.on_destroy(table, &block); end
 
     sig { params(event: RecordEvent).void }
@@ -136,71 +136,11 @@ module Wal
     sig { params(table: String).returns(T::Boolean) }
     def should_watch_table?(table); end
 
-    sig { params(event: BeginTransactionEvent).returns(Symbol) }
+    sig { params(event: Wal::BeginTransactionEvent).returns(Symbol) }
     def aggregation_strategy(event); end
 
-    sig { override.params(event: Event).void }
+    sig { override.params(event: Wal::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
@@ -210,31 +150,11 @@ module Wal
     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 }
+    sig { params(watcher: Wal::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]) }
+    sig { params(watcher: Wal::Watcher, publications: T::Array[String]).returns(T::Enumerator::Lazy[Wal::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
@@ -244,24 +164,23 @@ module Wal
     extend T::Sig
     extend T::Helpers
 
-    sig { abstract.params(events: T::Enumerator[Event]).void }
+    sig { abstract.params(events: T::Enumerator[Wal::Event]).void }
     def on_transaction_events(events); end
 
-    sig { params(event: BeginTransactionEvent).returns(Integer) }
+    sig { params(event: Wal::BeginTransactionEvent).returns(Integer) }
     def queue_size(event); end
 
-    sig { override.params(event: Event).void }
+    sig { override.params(event: Wal::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 }
+    sig { abstract.params(event: Wal::Event).void }
     def on_event(event); end
 
     sig { params(table: String).returns(T::Boolean) }
@@ -273,22 +192,22 @@ module Wal
     module SeparatedEvents
       extend T::Sig
 
-      sig { params(event: Event).void }
+      sig { params(event: Wal::Event).void }
       def on_event(event); end
 
-      sig { params(event: BeginTransactionEvent).void }
+      sig { params(event: Wal::BeginTransactionEvent).void }
       def on_begin(event); end
 
-      sig { params(event: InsertEvent).void }
+      sig { params(event: Wal::InsertEvent).void }
       def on_insert(event); end
 
-      sig { params(event: UpdateEvent).void }
+      sig { params(event: Wal::UpdateEvent).void }
       def on_update(event); end
 
-      sig { params(event: DeleteEvent).void }
+      sig { params(event: Wal::DeleteEvent).void }
       def on_delete(event); end
 
-      sig { params(event: CommitTransactionEvent).void }
+      sig { params(event: Wal::CommitTransactionEvent).void }
       def on_commit(event); end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: wal
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Rodrigo Navarro
 bindir: exe
 cert_chain: []
-date: 2025-06-22 00:00:00.000000000 Z
+date: 2025-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -79,62 +79,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7'
-- !ruby/object:Gem::Dependency
-  name: rbs
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: sorbet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: tapioca
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: parlour
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 email:
 - rnavarro@rnavarro.com.br
 executables:
@@ -157,109 +101,6 @@ files:
 - lib/wal/watcher.rb
 - rbi/wal.rbi
 - sig/wal.rbs
-- sorbet/config
-- sorbet/rbi/annotations/.gitattributes
-- sorbet/rbi/annotations/activemodel.rbi
-- sorbet/rbi/annotations/activerecord.rbi
-- sorbet/rbi/annotations/activesupport.rbi
-- sorbet/rbi/annotations/minitest.rbi
-- sorbet/rbi/annotations/rainbow.rbi
-- sorbet/rbi/gems/.gitattributes
-- sorbet/rbi/gems/actioncable@8.0.2.rbi
-- sorbet/rbi/gems/actionmailbox@8.0.2.rbi
-- sorbet/rbi/gems/actionmailer@8.0.2.rbi
-- sorbet/rbi/gems/actionpack@8.0.2.rbi
-- sorbet/rbi/gems/actiontext@8.0.2.rbi
-- sorbet/rbi/gems/actionview@8.0.2.rbi
-- sorbet/rbi/gems/activejob@8.0.2.rbi
-- sorbet/rbi/gems/activemodel@8.0.2.rbi
-- sorbet/rbi/gems/activerecord@8.0.2.rbi
-- sorbet/rbi/gems/activestorage@8.0.2.rbi
-- sorbet/rbi/gems/activesupport@8.0.2.rbi
-- sorbet/rbi/gems/ast@2.4.3.rbi
-- sorbet/rbi/gems/base64@0.3.0.rbi
-- sorbet/rbi/gems/benchmark@0.4.1.rbi
-- sorbet/rbi/gems/bigdecimal@3.2.2.rbi
-- sorbet/rbi/gems/builder@3.3.0.rbi
-- sorbet/rbi/gems/commander@5.0.0.rbi
-- sorbet/rbi/gems/concurrent-ruby@1.3.5.rbi
-- sorbet/rbi/gems/connection_pool@2.5.3.rbi
-- sorbet/rbi/gems/crass@1.0.6.rbi
-- sorbet/rbi/gems/date@3.4.1.rbi
-- sorbet/rbi/gems/diff-lcs@1.6.2.rbi
-- sorbet/rbi/gems/docker-api@2.4.0.rbi
-- sorbet/rbi/gems/docopt@0.6.1.rbi
-- sorbet/rbi/gems/drb@2.2.3.rbi
-- sorbet/rbi/gems/erubi@1.13.1.rbi
-- sorbet/rbi/gems/excon@1.2.7.rbi
-- sorbet/rbi/gems/globalid@1.2.1.rbi
-- sorbet/rbi/gems/highline@3.0.1.rbi
-- sorbet/rbi/gems/i18n@1.14.7.rbi
-- sorbet/rbi/gems/io-console@0.8.0.rbi
-- sorbet/rbi/gems/logger@1.7.0.rbi
-- sorbet/rbi/gems/loofah@2.24.1.rbi
-- sorbet/rbi/gems/mail@2.8.1.rbi
-- sorbet/rbi/gems/marcel@1.0.4.rbi
-- sorbet/rbi/gems/mini_mime@1.1.5.rbi
-- sorbet/rbi/gems/minitest@5.25.5.rbi
-- sorbet/rbi/gems/multi_json@1.15.0.rbi
-- sorbet/rbi/gems/net-imap@0.5.9.rbi
-- sorbet/rbi/gems/net-pop@0.1.2.rbi
-- sorbet/rbi/gems/net-protocol@0.2.2.rbi
-- sorbet/rbi/gems/net-smtp@0.5.1.rbi
-- sorbet/rbi/gems/netrc@0.11.0.rbi
-- sorbet/rbi/gems/nio4r@2.7.4.rbi
-- sorbet/rbi/gems/nokogiri@1.18.8.rbi
-- sorbet/rbi/gems/ostruct@0.6.2.rbi
-- sorbet/rbi/gems/parallel@1.27.0.rbi
-- sorbet/rbi/gems/parlour@9.1.1.rbi
-- sorbet/rbi/gems/parser@3.3.8.0.rbi
-- sorbet/rbi/gems/pg-replication-protocol@0.0.7.rbi
-- sorbet/rbi/gems/pg@1.5.9.rbi
-- sorbet/rbi/gems/pp@0.6.2.rbi
-- sorbet/rbi/gems/prettyprint@0.2.0.rbi
-- sorbet/rbi/gems/prism@1.4.0.rbi
-- sorbet/rbi/gems/psych@5.2.3.rbi
-- sorbet/rbi/gems/racc@1.8.1.rbi
-- sorbet/rbi/gems/rack-session@2.1.1.rbi
-- sorbet/rbi/gems/rack-test@2.2.0.rbi
-- sorbet/rbi/gems/rack@3.1.16.rbi
-- sorbet/rbi/gems/rackup@2.2.1.rbi
-- sorbet/rbi/gems/rails-dom-testing@2.3.0.rbi
-- sorbet/rbi/gems/rails-html-sanitizer@1.6.2.rbi
-- sorbet/rbi/gems/rails@8.0.2.rbi
-- sorbet/rbi/gems/railties@8.0.2.rbi
-- sorbet/rbi/gems/rainbow@3.1.1.rbi
-- sorbet/rbi/gems/rake@13.2.1.rbi
-- sorbet/rbi/gems/rbi@0.3.6.rbi
-- sorbet/rbi/gems/rbs@3.9.4.rbi
-- sorbet/rbi/gems/rdoc@6.12.0.rbi
-- sorbet/rbi/gems/reline@0.6.0.rbi
-- sorbet/rbi/gems/rexml@3.4.1.rbi
-- sorbet/rbi/gems/rspec-core@3.13.4.rbi
-- sorbet/rbi/gems/rspec-expectations@3.13.5.rbi
-- sorbet/rbi/gems/rspec-mocks@3.13.5.rbi
-- sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi
-- sorbet/rbi/gems/rspec-support@3.13.4.rbi
-- sorbet/rbi/gems/rspec@3.13.1.rbi
-- sorbet/rbi/gems/securerandom@0.4.1.rbi
-- sorbet/rbi/gems/spoom@1.6.3.rbi
-- sorbet/rbi/gems/stringio@3.1.5.rbi
-- sorbet/rbi/gems/tapioca@0.16.11.rbi
-- sorbet/rbi/gems/testcontainers-core@0.2.0.rbi
-- sorbet/rbi/gems/testcontainers-postgres@0.2.0.rbi
-- sorbet/rbi/gems/thor@1.3.2.rbi
-- sorbet/rbi/gems/timeout@0.4.3.rbi
-- sorbet/rbi/gems/tzinfo@2.0.6.rbi
-- sorbet/rbi/gems/uri@1.0.3.rbi
-- sorbet/rbi/gems/useragent@0.16.11.rbi
-- sorbet/rbi/gems/websocket-driver@0.8.0.rbi
-- sorbet/rbi/gems/websocket-extensions@0.1.5.rbi
-- sorbet/rbi/gems/yard-sorbet@0.9.0.rbi
-- sorbet/rbi/gems/yard@0.9.37.rbi
-- sorbet/rbi/gems/zeitwerk@2.7.3.rbi
-- sorbet/tapioca/config.yml
-- sorbet/tapioca/require.rb
 licenses:
 - MIT
 metadata:

data/sorbet/config

@@ -1,7 +0,0 @@
---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

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

data/sorbet/rbi/annotations/activemodel.rbi

@@ -1,89 +0,0 @@
-# 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

@@ -1,98 +0,0 @@
-# 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