paper_trail_diff 0.13.1 → 0.14.0

data/sig/generated/paper_trail_diff/prepared_activity_index.rbs

@@ -12,15 +12,42 @@ module PaperTrailDiff
     # : (untyped, Array[untyped]) -> Array[untyped]
     def versions: (untyped, Array[untyped]) -> Array[untyped]
 
+    # Children are found by key across the whole table, so an association to
+    # an STI subclass finds the rows of its siblings too. Only a row that was
+    # of the class at some point belongs to it, and of that row only the
+    # versions it had the class before or after.
+    # : (untyped, Array[untyped]) -> Array[untyped]
+    def member_ids: (untyped, Array[untyped]) -> Array[untyped]
+
+    # : (untyped, Array[untyped], ActivityRange) -> Array[untyped]
+    def member_versions: (untyped, Array[untyped], ActivityRange) -> Array[untyped]
+
+    # The versions of a through's join rows that are on its path. Under
+    # `source_type:`, a row is on it only while its type column names that
+    # class, so only the versions it had that type before or after count. A
+    # version saved before the type column existed has no type to read.
+    # : (Hash[Symbol, untyped], untyped) -> Array[untyped]
+    def join_versions: (Hash[Symbol, untyped], untyped) -> Array[untyped]
+
     # : (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
     def child_ids: (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
 
-    # : (untyped, Array[untyped], untyped, ?transactions: bool) -> Array[untyped]
-    def association_rows: (untyped, Array[untyped], untyped, ?transactions: bool) -> Array[untyped]
+    # The `belongs_to` targets each owner pointed at in the range: at its start
+    # and after each change inside it, plus the live row at a current end.
+    # : (untyped, Array[untyped], untyped, ActivityRange) -> Array[ActivityTargetCandidateLoader::Row]
+    def target_rows: (untyped, Array[untyped], untyped, ActivityRange) -> Array[ActivityTargetCandidateLoader::Row]
+
+    # : (untyped, untyped) -> bool
+    def loaded?: (untyped, untyped) -> bool
+
+    # PT-AT records HABTM membership once per transaction, under the
+    # association's name, so the rows are keyed by transaction id.
+    # : (untyped, Array[untyped], untyped) -> Array[untyped]
+    def habtm_rows: (untyped, Array[untyped], untyped) -> Array[untyped]
 
     private
 
-    @children: Hash[Array[String], untyped]
+    @children: Hash[untyped, untyped]
 
     @nodes: Hash[String, Array[untyped]]
 
@@ -30,7 +57,12 @@ module PaperTrailDiff
 
     @roots: Hash[Array[String], Array[untyped]]
 
-    @rows: Hash[Array[String], Hash[String, Array[untyped]]]
+    @rows: Hash[untyped, Hash[String, Array[untyped]]]
+
+    @targets: Hash[untyped, untyped]
+
+    # : (untyped, Array[untyped]) -> bool
+    def member_class?: (untyped, Array[untyped]) -> bool
 
     # : (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
     def historical_ids: (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
@@ -41,16 +73,26 @@ module PaperTrailDiff
     # : (untyped, untyped) -> untyped
     def child_rows: (untyped, untyped) -> untyped
 
+    # : (Hash[String, Array[ActivityTargetCandidateLoader::Row]], Array[untyped]) -> Array[ActivityTargetCandidateLoader::Row]
+    def rows_for: (Hash[String, Array[ActivityTargetCandidateLoader::Row]], Array[untyped]) -> Array[ActivityTargetCandidateLoader::Row]
+
+    # : (untyped, Array[ActivityTargetCandidateLoader::Row], ActivityRange) -> Array[ActivityTargetCandidateLoader::Row]
+    def eligible_rows: (untyped, Array[ActivityTargetCandidateLoader::Row], ActivityRange) -> Array[ActivityTargetCandidateLoader::Row]
+
+    # : (untyped, untyped) -> untyped
+    def target_candidates: (untyped, untyped) -> untyped
+
     # Mirrors VersionAssociationCandidateScope's before-window rule. The loaded
     # series includes changes to other owners too, so an old membership cannot
     # survive a later pre-window reassignment just because that owner is absent.
-    # : (untyped, Array[untyped], ActivityRange) -> bool
-    def eligible_child?: (untyped, Array[untyped], ActivityRange) -> bool
+    # : (untyped, untyped, untyped, String?, ActivityRange) -> bool
+    def eligible_version?: (untyped, untyped, untyped, String?, ActivityRange) -> bool
 
-    # : (untyped, untyped, bool) -> Hash[String, Array[untyped]]
-    def load_association_rows: (untyped, untyped, bool) -> Hash[String, Array[untyped]]
+    # : (untyped, untyped) -> Hash[String, Array[untyped]]
+    def load_habtm_rows: (untyped, untyped) -> Hash[String, Array[untyped]]
 
-    # : (Array[untyped], bool) -> Array[untyped]
-    def version_ids: (Array[untyped], bool) -> Array[untyped]
+    # A version without a transaction id names no rows, so it can stay in.
+    # : (Array[untyped]) -> Array[untyped]
+    def transaction_ids: (Array[untyped]) -> Array[untyped]
   end
 end

data/sig/generated/paper_trail_diff/prepared_edge_loader.rbs

@@ -3,11 +3,10 @@
 module PaperTrailDiff
   # Loads every historical identity that can participate in one association edge.
   class PreparedEdgeLoader
-    EDGE_LOADERS: untyped
-
     # : (PreparedRecordIndex, Array[untyped], ?start_at: untyped) -> void
     def initialize: (PreparedRecordIndex, Array[untyped], ?start_at: untyped) -> void
 
+    # HABTM alone also returns each root transaction's members.
     # : (untyped, Array[untyped], untyped) -> [Hash[String, Hash[Symbol, untyped]], Hash[String, Array[untyped]]?]
     def call: (untyped, Array[untyped], untyped) -> [ Hash[String, Hash[Symbol, untyped]], Hash[String, Array[untyped]]? ]
 
@@ -19,21 +18,14 @@ module PaperTrailDiff
 
     @transaction_ids: Array[untyped]
 
-    # : (untyped, Array[untyped], untyped) -> [Hash[String, Hash[Symbol, untyped]], nil]
-    def belongs_to_edge: (untyped, Array[untyped], untyped) -> [ Hash[String, Hash[Symbol, untyped]], nil ]
-
-    # : (untyped, Array[untyped], untyped) -> [Hash[String, Hash[Symbol, untyped]], nil]
-    def child_edge: (untyped, Array[untyped], untyped) -> [ Hash[String, Hash[Symbol, untyped]], nil ]
-
-    # : (untyped, Array[untyped], untyped) -> [Hash[String, Hash[Symbol, untyped]], Hash[String, Array[untyped]]]
-    def habtm_edge: (untyped, Array[untyped], untyped) -> [ Hash[String, Hash[Symbol, untyped]], Hash[String, Array[untyped]] ]
-
     # : (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
     def belongs_to_groups: (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
 
     # : (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
     def child_groups: (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
 
+    # A transaction more than one owner recorded members in is left out, so
+    # its read falls back to HistoricalAssociationReifier, which raises.
     # : (untyped, untyped) -> [Hash[String, Hash[Symbol, untyped]], Hash[String, Array[untyped]]]
     def habtm_groups: (untyped, untyped) -> [ Hash[String, Hash[Symbol, untyped]], Hash[String, Array[untyped]] ]
 
@@ -64,7 +56,7 @@ module PaperTrailDiff
     # : (untyped, Array[untyped], ?owners: Hash[String, Array[untyped]]?) -> Hash[String, Hash[Symbol, untyped]]
     def group_for: (untyped, Array[untyped], ?owners: Hash[String, Array[untyped]]?) -> Hash[String, Hash[Symbol, untyped]]
 
-    # Keyed rather than scanned so that a wide edge stays linear in its width.
+    # A set rather than a scan, so that a wide edge stays linear in its width.
     # : (Array[Array[untyped]]) -> Hash[String, Array[untyped]]
     def group_ids_by_owner: (Array[Array[untyped]]) -> Hash[String, Array[untyped]]
 

data/sig/generated/paper_trail_diff/prepared_history.rbs

@@ -10,8 +10,9 @@ module PaperTrailDiff
     # : (PreparedRecordIndex, ?activity_index: PreparedActivityIndex?) -> void
     def initialize: (PreparedRecordIndex, ?activity_index: PreparedActivityIndex?) -> void
 
-    # : (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> void
-    def merge_edge: (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> void
+    # Returns every group the edge now holds.
+    # : (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
+    def merge_edge: (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
 
     # : (untyped, untyped) -> Hash[String, Hash[Symbol, untyped]]
     def edge: (untyped, untyped) -> Hash[String, Hash[Symbol, untyped]]
@@ -31,11 +32,15 @@ module PaperTrailDiff
     # : (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
     def snapshot_states: (PreparedRecordState, untyped, untyped) -> [ bool, Array[PreparedRecordState] ]
 
-    # : (untyped, untyped, untyped, habtm_boundary: untyped) -> [bool, Array[untyped]]
-    def resolve: (untyped, untyped, untyped, habtm_boundary: untyped) -> [ bool, Array[untyped] ]
+    # Unranked, as a part of a has_many through is read, it returns every row
+    # the part's conditions admit, a record reached twice appearing twice.
+    # : (untyped, untyped, untyped, habtm_boundary: untyped, ?ranked: bool) -> [bool, Array[untyped]]
+    def resolve: (untyped, untyped, untyped, habtm_boundary: untyped, ?ranked: bool) -> [ bool, Array[untyped] ]
 
     private
 
+    @conditions: ScopeCondition::Cache
+
     @edges: Hash[Array[String], Hash[String, Hash[Symbol, untyped]]]
 
     @habtm: Hash[Array[String], Hash[String, Array[untyped]]]
@@ -46,35 +51,41 @@ module PaperTrailDiff
 
     @unsupported: Hash[Array[String], bool]
 
-    # : (untyped, untyped) -> bool
-    def supported?: (untyped, untyped) -> bool
+    # A polymorphic target's class is known only once a record names it, so
+    # belongs_to_records reads its scope for each record instead.
+    # : (untyped, untyped, bool) -> bool
+    def supported?: (untyped, untyped, bool) -> bool
 
-    # : (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def direct_records: (untyped, untyped, untyped, untyped) -> Array[untyped]?
+    # : (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
+    def direct_records: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
 
-    # : (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def resolve_belongs_to: (untyped, untyped, untyped, untyped) -> Array[untyped]?
+    # : (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
+    def resolve_belongs_to: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
 
-    # : (untyped, untyped, untyped, untyped) -> Array[untyped]
-    def resolve_children: (untyped, untyped, untyped, untyped) -> Array[untyped]
+    # : (untyped, untyped, untyped, untyped, bool) -> Array[untyped]
+    def resolve_children: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]
 
-    # : (untyped, untyped, untyped) -> Array[untyped]?
-    def belongs_to_records: (untyped, untyped, untyped) -> Array[untyped]?
+    # : (untyped, untyped, untyped, bool) -> Array[untyped]?
+    def belongs_to_records: (untyped, untyped, untyped, bool) -> Array[untyped]?
 
-    # : (untyped, untyped, untyped) -> Array[untyped]
-    def child_records: (untyped, untyped, untyped) -> Array[untyped]
+    # : (untyped, untyped, untyped, bool) -> Array[untyped]
+    def child_records: (untyped, untyped, untyped, bool) -> Array[untyped]
 
     # : (Hash[Symbol, untyped], untyped) -> Array[untyped]
     def child_ids_for: (Hash[Symbol, untyped], untyped) -> Array[untyped]
 
-    # : (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def habtm_records: (untyped, untyped, untyped, untyped) -> Array[untyped]?
+    # : (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
+    def habtm_records: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
 
-    # : (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def through_records: (untyped, untyped, untyped, untyped) -> Array[untyped]?
+    # A has_many through reads its parts unranked, as its query does. Its own
+    # scope applies to each row, and a ranked read then keeps a record reached
+    # twice as one member.
+    # : (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
+    def through_records: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
 
-    # : (Array[untyped], untyped, untyped, untyped) -> Array[[bool, Array[untyped]]]
-    def resolve_sources: (Array[untyped], untyped, untyped, untyped) -> Array[[ bool, Array[untyped] ]]
+    # The source records of each join record, once for each join.
+    # : (untyped, untyped, ^(untyped, untyped) -> [bool, Array[untyped]]) -> Array[untyped]?
+    def through_rows: (untyped, untyped, ^(untyped, untyped) -> [ bool, Array[untyped] ]) -> Array[untyped]?
 
     # : (untyped, untyped, untyped) -> bool
     def member_of?: (untyped, untyped, untyped) -> bool

data/sig/generated/paper_trail_diff/prepared_history_loader.rbs

@@ -3,19 +3,22 @@
 module PaperTrailDiff
   # Expands the explicit association tree into a request-scoped PreparedHistory.
   class PreparedHistoryLoader
-    # : (untyped, root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, ?root_ids: Array[untyped], ?start_at: untyped, ?end_at: untyped, ?live_records: Array[untyped]) -> void
-    def initialize: (untyped, root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, ?root_ids: Array[untyped], ?start_at: untyped, ?end_at: untyped, ?live_records: Array[untyped]) -> void
+    # Without `end_at`, the activity range closes on the last root version.
+    # : (untyped, root_ids: Array[untyped], root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, start_at: untyped, end_at: untyped, live_records: Array[untyped]) -> void
+    def initialize: (untyped, root_ids: Array[untyped], root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, start_at: untyped, end_at: untyped, live_records: Array[untyped]) -> void
 
     # : () -> PreparedHistory
     def call: () -> PreparedHistory
 
     private
 
+    @activity: PreparedActivityIndex
+
     @edges: PreparedEdgeLoader
 
     @history: PreparedHistory
 
-    @prepared: Hash[Array[String], Array[String]]
+    @prepared: Hash[untyped, Array[String]]
 
     @record: untyped
 
@@ -35,24 +38,26 @@ module PaperTrailDiff
     # : (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
     def prepare_reflection: (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
 
+    # Either part can itself be a through, which has no key of its own to
+    # read, so each part is prepared as what it is. Like an edge, it returns
+    # every group it holds, not only those of these owners.
     # : (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
     def prepare_through: (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
 
     # : (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
     def prepare_edge: (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
 
-    # : (untyped, Array[untyped], untyped) -> Array[untyped]
-    def unprepared_ids: (untyped, Array[untyped], untyped) -> Array[untyped]
+    # A reflection belongs to the class that declares it, so it alone names
+    # the edge; a subclass that inherits it reads the same records.
+    # : (Array[untyped], untyped) -> Array[untyped]
+    def unprepared_ids: (Array[untyped], untyped) -> Array[untyped]
 
-    # : (untyped, Array[untyped], untyped) -> void
-    def mark_prepared: (untyped, Array[untyped], untyped) -> void
+    # : (Array[untyped], untyped) -> void
+    def mark_prepared: (Array[untyped], untyped) -> void
 
     # : (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> void
     def mark_unsupported: (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> void
 
-    # : (untyped) -> bool
-    def deferred_macro?: (untyped) -> bool
-
     # : (Hash[String, Hash[Symbol, untyped]]) -> void
     def load_groups: (Hash[String, Hash[Symbol, untyped]]) -> void
 
@@ -62,9 +67,6 @@ module PaperTrailDiff
     # : (untyped) -> bool
     def versioned?: (untyped) -> bool
 
-    # : (untyped, untyped) -> Array[String]
-    def edge_key: (untyped, untyped) -> Array[String]
-
     # : (Hash[String, Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
     def merge_groups: (Hash[String, Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
   end

data/sig/generated/paper_trail_diff/prepared_record_index.rbs

@@ -81,6 +81,15 @@ module PaperTrailDiff
     # : () -> Array[PreparedRecordState]
     def states: () -> Array[PreparedRecordState]
 
+    # The classes the record had at any point, or either side of one version.
+    # : (?untyped) -> Array[untyped]
+    def model_classes: (?untyped) -> Array[untyped]
+
+    # The states either side of one version; a create has none before it and a
+    # destroy none after.
+    # : (untyped) -> Array[PreparedRecordState]
+    def states_around: (untyped) -> Array[PreparedRecordState]
+
     # : (untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
     def transition: (untyped) -> [ Hash[untyped, untyped], Hash[untyped, untyped] ]?
 
@@ -153,6 +162,12 @@ module PaperTrailDiff
     # : (untyped, untyped) -> Array[untyped]
     def versions_for_id: (untyped, untyped) -> Array[untyped]
 
+    # : (untyped, untyped, ?untyped) -> Array[untyped]
+    def model_classes: (untyped, untyped, ?untyped) -> Array[untyped]
+
+    # : (untyped, untyped, untyped) -> Array[PreparedRecordState]
+    def states_around: (untyped, untyped, untyped) -> Array[PreparedRecordState]
+
     # : (untyped, untyped) -> bool
     def loaded?: (untyped, untyped) -> bool
 

data/sig/generated/paper_trail_diff/prepared_state_association_reader.rbs

@@ -1,31 +1,76 @@
 # Generated from lib/paper_trail_diff/prepared_state_association_reader.rb with RBS::Inline
 
 module PaperTrailDiff
-  # Reads plain direct edges without creating AR records for their members.
+  # Reads plain edges without creating AR records for their members: direct
+  # edges, polymorphic `belongs_to`, and `has_many :through` built from them.
   class PreparedStateAssociationReader
-    # : (PreparedRecordIndex, untyped) -> void
-    def initialize: (PreparedRecordIndex, untyped) -> void
+    # : (PreparedRecordIndex, untyped, ScopeCondition::Cache) -> void
+    def initialize: (PreparedRecordIndex, untyped, ScopeCondition::Cache) -> void
 
-    # : (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
-    def call: (PreparedRecordState, untyped, untyped) -> [ bool, Array[PreparedRecordState] ]
+    # Unranked, as a part of a has_many through is read, it returns every row
+    # the part's conditions admit, a record reached twice appearing twice.
+    # : (PreparedRecordState, untyped, untyped, ?ranked: bool) -> [bool, Array[PreparedRecordState]]
+    def call: (PreparedRecordState, untyped, untyped, ?ranked: bool) -> [ bool, Array[PreparedRecordState] ]
 
     private
 
+    @conditions: ScopeCondition::Cache
+
     @edges: untyped
 
     @records: PreparedRecordIndex
 
-    # : (untyped) -> bool
-    def supported?: (untyped) -> bool
+    # A polymorphic target's class is known only once a record names it, so
+    # `target` reads its scope for each record instead.
+    # : (untyped, bool) -> bool
+    def supported?: (untyped, bool) -> bool
+
+    # : (PreparedRecordState, untyped, bool, ?untyped) -> bool
+    def in_scope?: (PreparedRecordState, untyped, bool, ?untyped) -> bool
+
+    # A type that names no class, or a class whose scope cannot be read as
+    # conditions, is left to the record path, which raises for the first and
+    # reads the second through its association.
+    # : (PreparedRecordState, untyped, untyped, bool) -> [bool, Array[PreparedRecordState]]
+    def target: (PreparedRecordState, untyped, untyped, bool) -> [ bool, Array[PreparedRecordState] ]
+
+    # : (PreparedRecordState, untyped) -> untyped
+    def target_class: (PreparedRecordState, untyped) -> untyped
+
+    # The members of each join record the owner had at the boundary, as
+    # PreparedHistory#through_records reads them from records. Under
+    # `source_type:`, only join records of that type count. A has_many
+    # through reads its parts unranked, as its query does.
+    # : (PreparedRecordState, untyped, untyped, bool) -> [bool, Array[PreparedRecordState]]
+    def through: (PreparedRecordState, untyped, untyped, bool) -> [ bool, Array[PreparedRecordState] ]
 
-    # : (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
-    def children: (PreparedRecordState, untyped, untyped) -> [ bool, Array[PreparedRecordState] ]
+    # The through's own scope applies after its parts' scopes, to each row,
+    # and a ranked read then keeps a record reached twice as one member.
+    # : (untyped, Array[PreparedRecordState], bool) -> Array[PreparedRecordState]
+    def through_members: (untyped, Array[PreparedRecordState], bool) -> Array[PreparedRecordState]
+
+    # A has_one keeps the first of its records.
+    # : (untyped, Array[PreparedRecordState]) -> Array[PreparedRecordState]
+    def first_if_one: (untyped, Array[PreparedRecordState]) -> Array[PreparedRecordState]
+
+    # : (untyped, PreparedRecordState) -> bool
+    def typed_join?: (untyped, PreparedRecordState) -> bool
+
+    # A record reached through two join records is one member.
+    # : (PreparedRecordState) -> Array[untyped]
+    def identity: (PreparedRecordState) -> Array[untyped]
+
+    # : (PreparedRecordState, untyped, untyped, bool) -> [bool, Array[PreparedRecordState]]
+    def children: (PreparedRecordState, untyped, untyped, bool) -> [ bool, Array[PreparedRecordState] ]
 
     # : (untyped, PreparedRecordState) -> Array[untyped]
     def ids_for: (untyped, PreparedRecordState) -> Array[untyped]
 
-    # : (PreparedRecordState, PreparedRecordState, untyped) -> bool
-    def member?: (PreparedRecordState, PreparedRecordState, untyped) -> bool
+    # : (PreparedRecordState, PreparedRecordState, untyped, bool) -> bool
+    def member?: (PreparedRecordState, PreparedRecordState, untyped, bool) -> bool
+
+    # : (PreparedRecordState) -> String
+    def owner_id: (PreparedRecordState) -> String
 
     # : (PreparedRecordState, untyped, untyped) -> bool
     def matching_type?: (PreparedRecordState, untyped, untyped) -> bool

data/sig/generated/paper_trail_diff/recorded_changes.rbs

@@ -0,0 +1,47 @@
+# Generated from lib/paper_trail_diff/recorded_changes.rb with RBS::Inline
+
+module PaperTrailDiff
+  # The changes PaperTrail wrote with one version, typed by the version's model.
+  #
+  # A step's diff compares reconstructed states, so it also holds whatever was
+  # saved without a version before the next one was read. This is the other
+  # account of the same event: only what PaperTrail recorded for it. Comparing
+  # the two is how a caller tells an unrecorded write from the event's own edit.
+  #
+  # PaperTrail's `version.changeset` finds the model through `version.item`,
+  # which is a query per version and nothing at all once the record is deleted.
+  # The version already names its model, so neither is needed here.
+  class RecordedChanges
+    IGNORE_NAMES_REQUIRED: ::String
+
+    # : (untyped, ignore: untyped) -> Hash[String, ValueChange]?
+    def self.call: (untyped, ignore: untyped) -> Hash[String, ValueChange]?
+
+    # : (untyped, ignore: untyped) -> void
+    def initialize: (untyped, ignore: untyped) -> void
+
+    # : () -> Hash[String, ValueChange]?
+    def call: () -> Hash[String, ValueChange]?
+
+    private
+
+    @ignore: untyped
+
+    @version: untyped
+
+    # Validated before anything is read, so a bad option fails the same way
+    # whether or not this version happened to record changes. Subclasses of
+    # Array and String pass, as in other methods' `ignore:`; Symbol has none.
+    # : () -> Array[String]
+    def ignored_names: () -> Array[String]
+
+    # Without the column, or with it left empty for this version, nothing was
+    # recorded. That is not the same answer as a recorded empty changeset.
+    # : () -> bool
+    def recorded?: () -> bool
+
+    # Primary keys identify the record rather than describe it, as in a diff.
+    # : (untyped, Array[String]) -> Hash[String, ValueChange]
+    def value_changes: (untyped, Array[String]) -> Hash[String, ValueChange]
+  end
+end

data/sig/generated/paper_trail_diff/recorded_class.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/paper_trail_diff/recorded_class.rb with RBS::Inline
+
+module PaperTrailDiff
+  # The class a record had at one version, which decides the associations it
+  # can have. Without an `item_subtype` column PaperTrail stores only the base
+  # class, so an STI subclass is read from the stored inheritance column: the
+  # state before the change, or for a create, the value it was created with.
+  # A version that stored neither stays on the base class.
+  module RecordedClass
+    # : (untyped) -> untyped
+    def self?.for: (untyped) -> untyped
+
+    # : (untyped) -> bool
+    def self?.sti_base?: (untyped) -> bool
+
+    # : (untyped, untyped) -> untyped
+    def self?.stored_type: (untyped, untyped) -> untyped
+
+    # : (StandardError) -> bool
+    def self?.subclass_not_found?: (StandardError) -> bool
+  end
+end