Domain::Users::FaUser aux table migration

sorbet/rbi/dsl/domain/post_group/sofurry_folder.rbi

@@ -47,6 +47,9 @@ class Domain::PostGroup::SofurryFolder
     sig { returns(T::Array[Symbol]) }
     def attr_json_registry; end
 
+    sig { params(field: Symbol, interval: ActiveSupport::Duration).void }
+    def due_timestamp(field, interval); end
+
     sig { returns(ColorLogger) }
     def logger; end
 

sorbet/rbi/dsl/domain/user.rbi

@@ -47,6 +47,9 @@ class Domain::User
     sig { returns(T::Array[Symbol]) }
     def attr_json_registry; end
 
+    sig { params(field: Symbol, interval: ActiveSupport::Duration).void }
+    def due_timestamp(field, interval); end
+
     sig { returns(ColorLogger) }
     def logger; end
 

sorbet/rbi/dsl/domain/user/e621_user.rbi

@@ -48,6 +48,9 @@ class Domain::User::E621User
     sig { returns(T::Array[Symbol]) }
     def attr_json_registry; end
 
+    sig { params(field: Symbol, interval: ActiveSupport::Duration).void }
+    def due_timestamp(field, interval); end
+
     sig { returns(ColorLogger) }
     def logger; end
 

sorbet/rbi/dsl/domain/user/fa_user.rbi

@@ -63,6 +63,9 @@ class Domain::User::FaUser
     sig { returns(T::Array[Symbol]) }
     def attr_json_registry; end
 
+    sig { params(field: Symbol, interval: ActiveSupport::Duration).void }
+    def due_timestamp(field, interval); end
+
     sig { returns(ColorLogger) }
     def logger; end
 
@@ -525,6 +528,9 @@ class Domain::User::FaUser
     sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::UserAvatar) }
     def build_avatar(*args, &blk); end
 
+    sig { params(args: T.untyped, blk: T.untyped).returns(::DomainUsersFaAux) }
+    def build_domain_users_fa_aux(*args, &blk); end
+
     sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
     def build_last_gallery_page_log_entry(*args, &blk); end
 
@@ -537,6 +543,12 @@ class Domain::User::FaUser
     sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::UserAvatar) }
     def create_avatar!(*args, &blk); end
 
+    sig { params(args: T.untyped, blk: T.untyped).returns(::DomainUsersFaAux) }
+    def create_domain_users_fa_aux(*args, &blk); end
+
+    sig { params(args: T.untyped, blk: T.untyped).returns(::DomainUsersFaAux) }
+    def create_domain_users_fa_aux!(*args, &blk); end
+
     sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
     def create_last_gallery_page_log_entry(*args, &blk); end
 
@@ -549,6 +561,12 @@ class Domain::User::FaUser
     sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
     def create_last_user_page_log_entry!(*args, &blk); end
 
+    sig { returns(T.nilable(::DomainUsersFaAux)) }
+    def domain_users_fa_aux; end
+
+    sig { params(value: T.nilable(::DomainUsersFaAux)).void }
+    def domain_users_fa_aux=(value); end
+
     sig { returns(T::Array[T.untyped]) }
     def faved_post_ids; end
 
@@ -646,6 +664,9 @@ class Domain::User::FaUser
     sig { returns(T.nilable(::Domain::UserAvatar)) }
     def reload_avatar; end
 
+    sig { returns(T.nilable(::DomainUsersFaAux)) }
+    def reload_domain_users_fa_aux; end
+
     sig { returns(T.nilable(::HttpLogEntry)) }
     def reload_last_gallery_page_log_entry; end
 
@@ -655,6 +676,9 @@ class Domain::User::FaUser
     sig { void }
     def reset_avatar; end
 
+    sig { void }
+    def reset_domain_users_fa_aux; end
+
     sig { void }
     def reset_last_gallery_page_log_entry; end
 
@@ -805,15 +829,6 @@ class Domain::User::FaUser
     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 not_state_account_disabled(*args, &blk); end
-
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
-    def not_state_error(*args, &blk); end
-
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
-    def not_state_ok(*args, &blk); end
-
     sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
     def null_relation?(*args, &blk); end
 
@@ -878,15 +893,6 @@ class Domain::User::FaUser
     end
     def select(*args, &blk); end
 
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
-    def state_account_disabled(*args, &blk); end
-
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
-    def state_error(*args, &blk); end
-
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
-    def state_ok(*args, &blk); end
-
     sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
     def strict_loading(*args, &blk); end
 
@@ -2347,31 +2353,31 @@ class Domain::User::FaUser
     sig { returns(T::Boolean) }
     def saved_change_to_scanned_favs_at?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def saved_change_to_scanned_followed_by_at; end
 
     sig { returns(T::Boolean) }
     def saved_change_to_scanned_followed_by_at?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def saved_change_to_scanned_follows_at; end
 
     sig { returns(T::Boolean) }
     def saved_change_to_scanned_follows_at?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def saved_change_to_scanned_gallery_at; end
 
     sig { returns(T::Boolean) }
     def saved_change_to_scanned_gallery_at?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def saved_change_to_scanned_incremental_at; end
 
     sig { returns(T::Boolean) }
     def saved_change_to_scanned_incremental_at?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def saved_change_to_scanned_page_at; end
 
     sig { returns(T::Boolean) }
@@ -2470,16 +2476,16 @@ class Domain::User::FaUser
     sig { void }
     def scanned_favs_at_will_change!; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_followed_by_at; end
 
-    sig { params(value: T.nilable(::Time)).returns(T.nilable(::Time)) }
+    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_followed_by_at=(value); end
 
     sig { returns(T::Boolean) }
     def scanned_followed_by_at?; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_followed_by_at_before_last_save; end
 
     sig { returns(T.untyped) }
@@ -2488,43 +2494,53 @@ class Domain::User::FaUser
     sig { returns(T::Boolean) }
     def scanned_followed_by_at_came_from_user?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_followed_by_at_change; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_followed_by_at_change_to_be_saved; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_followed_by_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_followed_by_at_in_database; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_followed_by_at_previous_change; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_followed_by_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_followed_by_at_previously_was; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_followed_by_at_was; end
 
     sig { void }
     def scanned_followed_by_at_will_change!; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_follows_at; end
 
-    sig { params(value: T.nilable(::Time)).returns(T.nilable(::Time)) }
+    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_follows_at=(value); end
 
     sig { returns(T::Boolean) }
     def scanned_follows_at?; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_follows_at_before_last_save; end
 
     sig { returns(T.untyped) }
@@ -2533,43 +2549,53 @@ class Domain::User::FaUser
     sig { returns(T::Boolean) }
     def scanned_follows_at_came_from_user?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_follows_at_change; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_follows_at_change_to_be_saved; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_follows_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_follows_at_in_database; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_follows_at_previous_change; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_follows_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_follows_at_previously_was; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_follows_at_was; end
 
     sig { void }
     def scanned_follows_at_will_change!; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_gallery_at; end
 
-    sig { params(value: T.nilable(::Time)).returns(T.nilable(::Time)) }
+    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_gallery_at=(value); end
 
     sig { returns(T::Boolean) }
     def scanned_gallery_at?; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_gallery_at_before_last_save; end
 
     sig { returns(T.untyped) }
@@ -2578,43 +2604,53 @@ class Domain::User::FaUser
     sig { returns(T::Boolean) }
     def scanned_gallery_at_came_from_user?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_gallery_at_change; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_gallery_at_change_to_be_saved; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_gallery_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_gallery_at_in_database; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_gallery_at_previous_change; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_gallery_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_gallery_at_previously_was; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_gallery_at_was; end
 
     sig { void }
     def scanned_gallery_at_will_change!; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_incremental_at; end
 
-    sig { params(value: T.nilable(::Time)).returns(T.nilable(::Time)) }
+    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_incremental_at=(value); end
 
     sig { returns(T::Boolean) }
     def scanned_incremental_at?; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_incremental_at_before_last_save; end
 
     sig { returns(T.untyped) }
@@ -2623,43 +2659,53 @@ class Domain::User::FaUser
     sig { returns(T::Boolean) }
     def scanned_incremental_at_came_from_user?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_incremental_at_change; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_incremental_at_change_to_be_saved; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_incremental_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_incremental_at_in_database; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_incremental_at_previous_change; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_incremental_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_incremental_at_previously_was; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_incremental_at_was; end
 
     sig { void }
     def scanned_incremental_at_will_change!; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_page_at; end
 
-    sig { params(value: T.nilable(::Time)).returns(T.nilable(::Time)) }
+    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_page_at=(value); end
 
     sig { returns(T::Boolean) }
     def scanned_page_at?; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_page_at_before_last_save; end
 
     sig { returns(T.untyped) }
@@ -2668,28 +2714,38 @@ class Domain::User::FaUser
     sig { returns(T::Boolean) }
     def scanned_page_at_came_from_user?; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_page_at_change; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_page_at_change_to_be_saved; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_page_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_page_at_in_database; end
 
-    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
+    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
     def scanned_page_at_previous_change; end
 
-    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
+    sig do
+      params(
+        from: T.nilable(::ActiveSupport::TimeWithZone),
+        to: T.nilable(::ActiveSupport::TimeWithZone)
+      ).returns(T::Boolean)
+    end
     def scanned_page_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_page_at_previously_was; end
 
-    sig { returns(T.nilable(::Time)) }
+    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
     def scanned_page_at_was; end
 
     sig { void }
@@ -2698,7 +2754,7 @@ class Domain::User::FaUser
     sig { returns(T.nilable(::String)) }
     def state; end
 
-    sig { params(value: T.nilable(T.any(::String, ::Symbol))).returns(T.nilable(T.any(::String, ::Symbol))) }
+    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
     def state=(value); end
 
     sig { returns(T::Boolean) }
@@ -2719,12 +2775,7 @@ class Domain::User::FaUser
     sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
     def state_change_to_be_saved; end
 
-    sig do
-      params(
-        from: T.nilable(T.any(::String, ::Symbol)),
-        to: T.nilable(T.any(::String, ::Symbol))
-      ).returns(T::Boolean)
-    end
+    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
     def state_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
     sig { returns(T.nilable(::String)) }
@@ -2733,12 +2784,7 @@ class Domain::User::FaUser
     sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
     def state_previous_change; end
 
-    sig do
-      params(
-        from: T.nilable(T.any(::String, ::Symbol)),
-        to: T.nilable(T.any(::String, ::Symbol))
-      ).returns(T::Boolean)
-    end
+    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
     def state_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
     sig { returns(T.nilable(::String)) }
@@ -3266,15 +3312,6 @@ class Domain::User::FaUser
     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 not_state_account_disabled(*args, &blk); end
-
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
-    def not_state_error(*args, &blk); end
-
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
-    def not_state_ok(*args, &blk); end
-
     sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
     def null_relation?(*args, &blk); end
 
@@ -3339,15 +3376,6 @@ class Domain::User::FaUser
     end
     def select(*args, &blk); end
 
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
-    def state_account_disabled(*args, &blk); end
-
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
-    def state_error(*args, &blk); end
-
-    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
-    def state_ok(*args, &blk); end
-
     sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
     def strict_loading(*args, &blk); end
 

sorbet/rbi/dsl/domain/user/inkbunny_user.rbi

@@ -47,6 +47,9 @@ class Domain::User::InkbunnyUser
     sig { returns(T::Array[Symbol]) }
     def attr_json_registry; end
 
+    sig { params(field: Symbol, interval: ActiveSupport::Duration).void }
+    def due_timestamp(field, interval); end
+
     sig { returns(ColorLogger) }
     def logger; end
 

sorbet/rbi/dsl/domain/user/sofurry_user.rbi

@@ -54,6 +54,9 @@ class Domain::User::SofurryUser
     sig { returns(T::Array[Symbol]) }
     def attr_json_registry; end
 
+    sig { params(field: Symbol, interval: ActiveSupport::Duration).void }
+    def due_timestamp(field, interval); end
+
     sig { returns(ColorLogger) }
     def logger; end
 

sorbet/rbi/gems/has_aux_table@0.1.0-fb7912e3536c339cba55af54c3e647f69f5997f3.rbi

@@ -5,6 +5,55 @@
 # Please instead update this file by running `bin/tapioca gem has_aux_table`.
 
 
+# source://has_aux_table//lib/has_aux_table/relation_extensions.rb#6
+class ActiveRecord::Associations::AssociationScope
+  # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#15
+  def initialize(value_transformation); end
+
+  # source://has_aux_table//lib/has_aux_table/relation_extensions.rb#7
+  def get_chain(reflection, association, tracker); end
+
+  # source://has_aux_table//lib/has_aux_table/relation_extensions.rb#40
+  def scope(association); end
+
+  private
+
+  # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#124
+  def add_constraints(scope, owner, chain); end
+
+  # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#161
+  def apply_scope(scope, table, key, value); end
+
+  # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#169
+  def eval_scope(reflection, scope, owner); end
+
+  # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#54
+  def join(table, constraint); end
+
+  # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#58
+  def last_chain_scope(scope, reflection, owner); end
+
+  # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#81
+  def next_chain_scope(scope, reflection, next_reflection); end
+
+  # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#77
+  def transform_value(value); end
+
+  # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#52
+  def value_transformation; end
+
+  class << self
+    # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#10
+    def create(&block); end
+
+    # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#34
+    def get_bind_values(owner, chain); end
+
+    # source://activerecord/7.2.2.1/lib/active_record/associations/association_scope.rb#6
+    def scope(association); end
+  end
+end
+
 # source://has_aux_table//lib/has_aux_table/migration_extensions.rb#119
 class ActiveRecord::Migration
   include ::HasAuxTable::MigrationExtensions
@@ -201,15 +250,6 @@ class HasAuxTable::AuxTableConfig < ::T::Struct
   const :foreign_key, T.any(::String, ::Symbol, T::Array[T.any(::String, ::Symbol)])
   const :primary_key, T.any(::String, ::Symbol, T::Array[T.any(::String, ::Symbol)])
 
-  # source://has_aux_table//lib/has_aux_table/aux_table_config.rb#203
-  sig do
-    params(
-      relation: T.any(::ActiveRecord::Relation, T.class_of(ActiveRecord::Base)),
-      conditions: T::Hash[::String, T.untyped]
-    ).returns(::ActiveRecord::Relation)
-  end
-  def apply_split_conditions!(relation, conditions); end
-
   # source://has_aux_table//lib/has_aux_table/aux_table_config.rb#130
   sig { returns(::HasAuxTable::ModelClassHelper) }
   def aux; end
@@ -240,13 +280,13 @@ class HasAuxTable::AuxTableConfig < ::T::Struct
   sig { returns(::HasAuxTable::ModelClassHelper) }
   def main; end
 
-  # source://has_aux_table//lib/has_aux_table/aux_table_config.rb#218
+  # source://has_aux_table//lib/has_aux_table/aux_table_config.rb#204
   sig { params(conditions: T::Hash[::String, T.untyped]).returns(T::Hash[::String, T.untyped]) }
   def remap_conditions(conditions); end
 
   private
 
-  # source://has_aux_table//lib/has_aux_table/aux_table_config.rb#227
+  # source://has_aux_table//lib/has_aux_table/aux_table_config.rb#213
   sig { returns(T::Set[::String]) }
   def aux_rejected_column_names; end
 
@@ -301,23 +341,27 @@ module HasAuxTable::ClassMethods
 
   # Main DSL method for defining auxiliary tables
   #
-  # source://has_aux_table//lib/has_aux_table.rb#40
+  # source://has_aux_table//lib/has_aux_table.rb#54
   sig { params(aux_name: T.any(::String, ::Symbol)).returns(::HasAuxTable::AuxTableConfig) }
   def aux_table(aux_name); end
 
+  # source://has_aux_table//lib/has_aux_table.rb#43
+  sig { params(column_name: T.any(::String, ::Symbol)).returns(T.nilable(::HasAuxTable::AuxTableConfig)) }
+  def aux_table_for(column_name); end
+
   private
 
-  # source://has_aux_table//lib/has_aux_table.rb#200
+  # source://has_aux_table//lib/has_aux_table.rb#214
   sig { params(load_schema_method: ::Method, config: ::HasAuxTable::AuxTableConfig).void }
   def aux_config_load_schema!(load_schema_method, config); end
 
-  # source://has_aux_table//lib/has_aux_table.rb#342
+  # source://has_aux_table//lib/has_aux_table.rb#349
   sig { params(aux_table_name: ::Symbol, main_columns: T::Array[::String], aux_columns: T::Array[::String]).void }
   def check_for_overlapping_columns!(aux_table_name, main_columns, aux_columns); end
 
   # Generate auxiliary model class dynamically
   #
-  # source://has_aux_table//lib/has_aux_table.rb#75
+  # source://has_aux_table//lib/has_aux_table.rb#89
   sig do
     params(
       aux_name: ::Symbol,
@@ -327,43 +371,43 @@ module HasAuxTable::ClassMethods
   end
   def generate_aux_config(aux_name, foreign_key: T.unsafe(nil), primary_key: T.unsafe(nil)); end
 
-  # source://has_aux_table//lib/has_aux_table.rb#233
+  # source://has_aux_table//lib/has_aux_table.rb#257
   sig { params(config: ::HasAuxTable::AuxTableConfig).void }
   def setup_attribute_getter_setter_hooks!(config); end
 
-  # source://has_aux_table//lib/has_aux_table.rb#143
+  # source://has_aux_table//lib/has_aux_table.rb#157
   sig { params(config: ::HasAuxTable::AuxTableConfig).void }
   def setup_attribute_types_hook!(config); end
 
-  # source://has_aux_table//lib/has_aux_table.rb#324
+  # source://has_aux_table//lib/has_aux_table.rb#331
   sig { params(config: ::HasAuxTable::AuxTableConfig).void }
   def setup_attributes_hook!(config); end
 
-  # source://has_aux_table//lib/has_aux_table.rb#271
+  # source://has_aux_table//lib/has_aux_table.rb#296
   sig { params(config: ::HasAuxTable::AuxTableConfig).void }
   def setup_changed_hook!(config); end
 
-  # source://has_aux_table//lib/has_aux_table.rb#361
+  # source://has_aux_table//lib/has_aux_table.rb#368
   sig { params(config: ::HasAuxTable::AuxTableConfig).void }
   def setup_enum_hook!(config); end
 
-  # source://has_aux_table//lib/has_aux_table.rb#255
+  # source://has_aux_table//lib/has_aux_table.rb#280
   sig { params(config: ::HasAuxTable::AuxTableConfig).void }
   def setup_initialize_hook!(config); end
 
   # Hook into schema loading to generate attribute accessors when schema is loaded
   #
-  # source://has_aux_table//lib/has_aux_table.rb#184
+  # source://has_aux_table//lib/has_aux_table.rb#198
   sig { params(config: ::HasAuxTable::AuxTableConfig).void }
   def setup_load_schema_hook!(config); end
 
-  # source://has_aux_table//lib/has_aux_table.rb#306
-  sig { params(config: ::HasAuxTable::AuxTableConfig).void }
-  def setup_reload_hook!(config); end
-
-  # source://has_aux_table//lib/has_aux_table.rb#289
+  # source://has_aux_table//lib/has_aux_table.rb#314
   sig { params(config: ::HasAuxTable::AuxTableConfig).void }
   def setup_save_hook!(config); end
+
+  # source://has_aux_table//lib/has_aux_table.rb#411
+  sig { params(config: ::HasAuxTable::AuxTableConfig).void }
+  def setup_update_counter_hook!(config); end
 end
 
 # source://has_aux_table//lib/has_aux_table/key_type.rb#5
@@ -461,18 +505,18 @@ class HasAuxTable::ModelClassHelper < ::T::Struct
   end
 end
 
-# source://has_aux_table//lib/has_aux_table/relation_extensions.rb#5
+# source://has_aux_table//lib/has_aux_table/relation_extensions.rb#67
 module HasAuxTable::RelationExtensions
-  # source://has_aux_table//lib/has_aux_table/relation_extensions.rb#15
+  # source://has_aux_table//lib/has_aux_table/relation_extensions.rb#77
   sig { params(aux_config: ::HasAuxTable::AuxTableConfig).void }
   def setup_main_class_extensions!(aux_config); end
 
-  # source://has_aux_table//lib/has_aux_table/relation_extensions.rb#10
+  # source://has_aux_table//lib/has_aux_table/relation_extensions.rb#72
   sig { params(aux_config: ::HasAuxTable::AuxTableConfig).void }
   def setup_relation_extensions!(aux_config); end
 end
 
-# source://has_aux_table//lib/has_aux_table/relation_extensions.rb#7
+# source://has_aux_table//lib/has_aux_table/relation_extensions.rb#69
 HasAuxTable::RelationExtensions::Util = HasAuxTable::Util
 
 # source://has_aux_table//lib/has_aux_table/migration_extensions.rb#5

sorbet/tapioca/compilers/has_timestamps_with_due_at_dsl.rb

@@ -14,6 +14,16 @@ module Tapioca::Compilers
     sig { override.void }
     def decorate
       root.create_path(constant) do |klass|
+        klass.create_method(
+          "due_timestamp",
+          parameters: [
+            create_param("field", type: "Symbol"),
+            create_param("interval", type: "ActiveSupport::Duration"),
+          ],
+          class_method: true,
+          return_type: "void",
+        )
+
         klass.create_method(
           "attr_json_due_timestamp",
           parameters: [