paper_trail_diff 0.1.0

data/sig/generated/paper_trail_diff/association_discovery.rbs

@@ -0,0 +1,63 @@
+# Generated from lib/paper_trail_diff/association_discovery.rb with RBS::Inline
+
+module PaperTrailDiff
+  # One discoverable ActiveRecord association path.
+  class AssociationDescriptor
+    attr_reader path: String
+
+    attr_reader kind: Symbol
+
+    attr_reader target_type: String?
+
+    attr_reader through: String?
+
+    attr_reader polymorphic: bool
+
+    attr_reader cycle: bool
+
+    # : (path: String, kind: Symbol, target_type: String?, ?through: String?, ?flags: Array[Symbol]) -> void
+    def initialize: (path: String, kind: Symbol, target_type: String?, ?through: String?, ?flags: Array[Symbol]) -> void
+
+    # : () -> Hash[Symbol, untyped]
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+
+  # Discovers finite, supported association paths for configuration UIs.
+  class AssociationDiscovery
+    # : (untyped, max_depth: Integer) -> void
+    def initialize: (untyped, max_depth: Integer) -> void
+
+    # : () -> Array[AssociationDescriptor]
+    def call: () -> Array[AssociationDescriptor]
+
+    private
+
+    @max_depth: Integer
+
+    @model_class: untyped
+
+    # : (untyped, prefix: String, ancestry: Array[untyped], depth: Integer) -> Array[AssociationDescriptor]
+    def discover: (untyped, prefix: String, ancestry: Array[untyped], depth: Integer) -> Array[AssociationDescriptor]
+
+    # : (untyped, prefix: String, ancestry: Array[untyped], depth: Integer) -> Array[AssociationDescriptor]
+    def describe_and_descend: (untyped, prefix: String, ancestry: Array[untyped], depth: Integer) -> Array[AssociationDescriptor]
+
+    # : (untyped, String, untyped, bool) -> AssociationDescriptor
+    def descriptor_for: (untyped, String, untyped, bool) -> AssociationDescriptor
+
+    # : (untyped) -> Array[untyped]
+    def supported_reflections: (untyped) -> Array[untyped]
+
+    # : (untyped, untyped) -> bool
+    def paper_trail_versions?: (untyped, untyped) -> bool
+
+    # : (untyped) -> untyped
+    def reflection_target: (untyped) -> untyped
+
+    # : (untyped) -> String?
+    def reflection_target_name: (untyped) -> String?
+
+    # : (String, String) -> String
+    def association_path: (String, String) -> String
+  end
+end

data/sig/generated/paper_trail_diff/association_traversal.rbs

@@ -0,0 +1,54 @@
+# Generated from lib/paper_trail_diff/association_traversal.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Resolves and validates ActiveRecord reflections for a bounded association tree.
+  class AssociationTraversal
+    # : (AssociationTree) -> void
+    def initialize: (AssociationTree) -> void
+
+    # : (untyped) -> void
+    def validate!: (untyped) -> void
+
+    # : (untyped) -> Array[Array[untyped]]
+    def selected_reflections: (untyped) -> Array[Array[untyped]]
+
+    # : (untyped, untyped) -> void
+    def ensure_habtm_history!: (untyped, untyped) -> void
+
+    # : (untyped) -> Array[String]
+    def habtm_paths: (untyped) -> Array[String]
+
+    # : (untyped, AssociationTree, path: String) -> Array[untyped]
+    def reflections_for: (untyped, AssociationTree, path: String) -> Array[untyped]
+
+    # : (untyped) -> Array[String]
+    def incoming_relationship_columns: (untyped) -> Array[String]
+
+    private
+
+    @reflection_cache: Hash[Array[untyped], Array[untyped]]
+
+    @tree: AssociationTree
+
+    # : (untyped, AssociationTree, path: String) -> Array[Array[untyped]]
+    def collect_reflections: (untyped, AssociationTree, path: String) -> Array[Array[untyped]]
+
+    # : (untyped, AssociationTree, path: String) -> void
+    def validate_tree!: (untyped, AssociationTree, path: String) -> void
+
+    # : (untyped, AssociationTree, String) -> Array[untyped]
+    def requested_reflections: (untyped, AssociationTree, String) -> Array[untyped]
+
+    # : (untyped, String, String) -> untyped
+    def resolve_reflection: (untyped, String, String) -> untyped
+
+    # : (untyped, untyped) -> bool
+    def paper_trail_versions?: (untyped, untyped) -> bool
+
+    # : (untyped) -> bool
+    def habtm_reflection?: (untyped) -> bool
+
+    # : (String, String) -> String
+    def join_path: (String, String) -> String
+  end
+end

data/sig/generated/paper_trail_diff/branch_snapshot_refresher.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/paper_trail_diff/branch_snapshot_refresher.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Reconstructs selected root branches and merges them into a prior immutable snapshot.
+  class BranchSnapshotRefresher
+    # : (tree: AssociationTree, ignore_policy: IgnorePolicy, traversal: AssociationTraversal, pool: SnapshotPool, normalizer: SnapshotNormalizer, full_snapshotter: untyped, partial_snapshotter: untyped, association_reader: untyped) -> void
+    def initialize: (tree: AssociationTree, ignore_policy: IgnorePolicy, traversal: AssociationTraversal, pool: SnapshotPool, normalizer: SnapshotNormalizer, full_snapshotter: untyped, partial_snapshotter: untyped, association_reader: untyped) -> void
+
+    # : (untyped, untyped, RecordSnapshot?, event: ActivityEvent) -> RecordSnapshot?
+    def advance_root: (untyped, untyped, RecordSnapshot?, event: ActivityEvent) -> RecordSnapshot?
+
+    # : (untyped, untyped, RecordSnapshot?, Array[String], ?event: ActivityEvent?, ?isolated: bool) -> RecordSnapshot?
+    def call: (untyped, untyped, RecordSnapshot?, Array[String], ?event: ActivityEvent?, ?isolated: bool) -> RecordSnapshot?
+
+    private
+
+    @components: Hash[Array[String], [ AssociationTree, SnapshotNormalizer ]]
+
+    @event_refresher: ActivityEventSnapshotRefresher
+
+    @full_snapshotter: untyped
+
+    @ignore_policy: IgnorePolicy
+
+    @partial_snapshotter: untyped
+
+    @pool: SnapshotPool
+
+    @root_refresher: ActivityRootSnapshotRefresher
+
+    @traversal: AssociationTraversal
+
+    @tree: AssociationTree
+
+    # : (Array[untyped], RecordSnapshot, Array[String], ActivityEvent?, bool) -> [bool, RecordSnapshot?]
+    def incremental_event: (Array[untyped], RecordSnapshot, Array[String], ActivityEvent?, bool) -> [ bool, RecordSnapshot? ]
+
+    # : (untyped, untyped, RecordSnapshot, Array[String], ActivityEvent) -> RecordSnapshot?
+    def refresh_independent_branches: (untyped, untyped, RecordSnapshot, Array[String], ActivityEvent) -> RecordSnapshot?
+
+    # : (untyped, untyped, Array[String]) -> RecordSnapshot?
+    def partial_snapshot: (untyped, untyped, Array[String]) -> RecordSnapshot?
+
+    # : (Array[String]) -> [AssociationTree, SnapshotNormalizer]
+    def components: (Array[String]) -> [ AssociationTree, SnapshotNormalizer ]
+
+    # : (Array[String]) -> [AssociationTree, SnapshotNormalizer]
+    def build_components: (Array[String]) -> [ AssociationTree, SnapshotNormalizer ]
+
+    # : (untyped, untyped) -> RecordSnapshot?
+    def full_snapshot: (untyped, untyped) -> RecordSnapshot?
+
+    # : (RecordSnapshot, RecordSnapshot) -> RecordSnapshot
+    def merge: (RecordSnapshot, RecordSnapshot) -> RecordSnapshot
+  end
+end

data/sig/generated/paper_trail_diff/configuration.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/paper_trail_diff/configuration.rb with RBS::Inline
+
+module PaperTrailDiff
+  # An immutable, bounded tree built from explicit association paths.
+  class AssociationTree
+    attr_reader children: Hash[String, AssociationTree]
+
+    # : (untyped) -> AssociationTree
+    def self.build: (untyped) -> AssociationTree
+
+    # : (Hash[String, untyped], String) -> void
+    private def self.add_path: (Hash[String, untyped], String) -> void
+
+    # : (Hash[String, untyped]) -> AssociationTree
+    private def self.from_hash: (Hash[String, untyped]) -> AssociationTree
+
+    # : (untyped) -> bool
+    private def self.valid_values?: (untyped) -> bool
+
+    # : (Hash[String, AssociationTree]) -> void
+    def initialize: (Hash[String, AssociationTree]) -> void
+
+    # : () -> bool
+    def empty?: () -> bool
+
+    # : (String | Symbol) -> AssociationTree?
+    def child: (String | Symbol) -> AssociationTree?
+
+    # : (Array[String]) -> AssociationTree
+    def select: (Array[String]) -> AssociationTree
+
+    # : (?prefix: String) -> Array[String]
+    def paths: (?prefix: String) -> Array[String]
+  end
+
+  # Immutable rules for globally and path-specifically excluded attributes.
+  class IgnorePolicy
+    ROOT_PATH: ::String
+
+    VALID_KEYS: untyped
+
+    # : (untyped, association_paths: Array[String]) -> IgnorePolicy
+    def self.build: (untyped, association_paths: Array[String]) -> IgnorePolicy
+
+    # : (Hash[untyped, untyped]) -> Hash[String, untyped]
+    private def self.normalize_options: (Hash[untyped, untyped]) -> Hash[String, untyped]
+
+    # : (untyped, Array[String]) -> Hash[String, Array[String]]
+    private def self.normalize_paths: (untyped, Array[String]) -> Hash[String, Array[String]]
+
+    # : (Hash[String, Array[String]], untyped, untyped, Array[String]) -> void
+    private def self.add_path_rule: (Hash[String, Array[String]], untyped, untyped, Array[String]) -> void
+
+    # : (untyped, context: String) -> Array[String]
+    private def self.normalize_names: (untyped, context: String) -> Array[String]
+
+    attr_reader all: Array[String]
+
+    attr_reader paths: Hash[String, Array[String]]
+
+    # : (all: Array[String], paths: Hash[String, Array[String]]) -> void
+    def initialize: (all: Array[String], paths: Hash[String, Array[String]]) -> void
+
+    # : (String) -> Array[String]
+    def attributes_for: (String) -> Array[String]
+  end
+end

data/sig/generated/paper_trail_diff/diagnostics.rbs

@@ -0,0 +1,109 @@
+# Generated from lib/paper_trail_diff/diagnostics.rb with RBS::Inline
+
+module PaperTrailDiff
+  # One immutable historical-reconstruction setup finding.
+  class DiagnosticIssue
+    attr_reader severity: Symbol
+
+    attr_reader code: Symbol
+
+    attr_reader message: String
+
+    attr_reader path: String?
+
+    attr_reader version_id: untyped
+
+    # : (severity: Symbol, code: Symbol, message: String, ?path: String?, ?version_id: untyped) -> void
+    def initialize: (severity: Symbol, code: Symbol, message: String, ?path: String?, ?version_id: untyped) -> void
+
+    # : () -> Hash[Symbol, untyped]
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+
+  # Immutable diagnostics for a requested historical association comparison.
+  class DiagnosticReport
+    attr_reader issues: Array[DiagnosticIssue]
+
+    # : (issues: Array[DiagnosticIssue]) -> void
+    def initialize: (issues: Array[DiagnosticIssue]) -> void
+
+    # : () -> Array[DiagnosticIssue]
+    def errors: () -> Array[DiagnosticIssue]
+
+    # : () -> Array[DiagnosticIssue]
+    def warnings: () -> Array[DiagnosticIssue]
+
+    # : () -> bool
+    def ok?: () -> bool
+
+    # : () -> Hash[Symbol, untyped]
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+
+  # Performs read-only checks for known PaperTrail/PT-AT reconstruction hazards.
+  class HistoryDiagnostics
+    # : (untyped, untyped, associations: Array[String | Symbol]) -> void
+    def initialize: (untyped, untyped, associations: Array[String | Symbol]) -> void
+
+    # : () -> DiagnosticReport
+    def call: () -> DiagnosticReport
+
+    private
+
+    @from_version: untyped
+
+    @issues: Array[DiagnosticIssue]
+
+    @to_version: untyped
+
+    @tree: AssociationTree
+
+    # : () -> untyped
+    def validated_model_class: () -> untyped
+
+    # : (Array[Array[untyped]]) -> void
+    def inspect_targets: (Array[Array[untyped]]) -> void
+
+    # : (Array[Array[untyped]]) -> void
+    def inspect_habtm: (Array[Array[untyped]]) -> void
+
+    # : (untyped) -> void
+    def inspect_checkpoint_timestamp: (untyped) -> void
+
+    # : (Array[String]) -> void
+    def inspect_transaction_metadata: (Array[String]) -> void
+
+    # : (untyped, String) -> void
+    def inspect_versioned_model: (untyped, String) -> void
+
+    # : (untyped, String) -> void
+    def inspect_through_model: (untyped, String) -> void
+
+    # : (untyped) -> bool
+    def model_versioned?: (untyped) -> bool
+
+    # : (untyped) -> bool
+    def synchronized_timestamp_disabled?: (untyped) -> bool
+
+    # : () -> bool
+    def association_tracking_available?: () -> bool
+
+    # : (untyped) -> Array[String]
+    def version_identity: (untyped) -> Array[String]
+
+    # : (untyped) -> String
+    def version_type: (untyped) -> String
+
+    # : () -> String
+    def tracking_unavailable_message: () -> String
+
+    # : (Symbol, String, ?String?, ?untyped) -> void
+    def add_error: (Symbol, String, ?String?, ?untyped) -> void
+
+    # : (Symbol, String, ?String?) -> void
+    def add_warning: (Symbol, String, ?String?) -> void
+
+    # : (Symbol, Symbol, String, String?, untyped) -> void
+    def add_issue: (Symbol, Symbol, String, String?, untyped) -> void
+  end
+end

data/sig/generated/paper_trail_diff/endpoint.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/paper_trail_diff/endpoint.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Validates and describes explicit PaperTrail-version and live-record endpoints.
+  module Endpoint
+    # : (untyped, untyped) -> void
+    def self?.validate_pair!: (untyped, untyped) -> void
+
+    # : (untyped) -> void
+    def self?.validate!: (untyped) -> void
+
+    # : (untyped) -> bool
+    def self?.version?: (untyped) -> bool
+
+    # : (untyped) -> bool
+    def self?.record?: (untyped) -> bool
+
+    # : (untyped) -> Array[String]
+    def self?.identity: (untyped) -> Array[String]
+
+    # : (untyped) -> untyped
+    def self?.model_class: (untyped) -> untyped
+
+    # : (untyped) -> untyped
+    def self?.reload_record: (untyped) -> untyped
+
+    # : (untyped) -> void
+    def self?.validate_record!: (untyped) -> void
+  end
+end

data/sig/generated/paper_trail_diff/engine.rbs

@@ -0,0 +1,54 @@
+# Generated from lib/paper_trail_diff/engine.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Pure snapshot comparison. This class has no ActiveRecord or PaperTrail dependencies.
+  class Engine
+    # : (RecordSnapshot?, RecordSnapshot?) -> Diff
+    def self.compare: (RecordSnapshot?, RecordSnapshot?) -> Diff
+
+    # : (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, ValueChange]
+    private def self.compare_attributes: (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, ValueChange]
+
+    # : (association_snapshots, association_snapshots) -> association_diffs
+    private def self.compare_associations: (association_snapshots, association_snapshots) -> association_diffs
+
+    # : (AssociationSnapshot?, AssociationSnapshot?) -> [AssociationSnapshot, AssociationSnapshot]
+    private def self.association_pair: (AssociationSnapshot?, AssociationSnapshot?) -> [ AssociationSnapshot, AssociationSnapshot ]
+
+    # : (AssociationSnapshot?, AssociationSnapshot?) -> void
+    private def self.validate_association_kinds!: (AssociationSnapshot?, AssociationSnapshot?) -> void
+
+    # : (AssociationSnapshot?, AssociationSnapshot?) -> bool
+    private def self.kinds_differ?: (AssociationSnapshot?, AssociationSnapshot?) -> bool
+
+    # : (AssociationSnapshot, AssociationSnapshot) -> association_diff
+    private def self.compare_association: (AssociationSnapshot, AssociationSnapshot) -> association_diff
+
+    # : (AssociationSnapshot, AssociationSnapshot) -> ToOneAssociationDiff
+    private def self.compare_to_one: (AssociationSnapshot, AssociationSnapshot) -> ToOneAssociationDiff
+
+    # : (RecordSnapshot?, RecordSnapshot?) -> ValueChange?
+    private def self.relationship_change: (RecordSnapshot?, RecordSnapshot?) -> ValueChange?
+
+    # : (RecordSnapshot, RecordSnapshot) -> RecordChange?
+    private def self.compare_record: (RecordSnapshot, RecordSnapshot) -> RecordChange?
+
+    # : (AssociationSnapshot, AssociationSnapshot) -> CollectionAssociationDiff
+    private def self.compare_collection: (AssociationSnapshot, AssociationSnapshot) -> CollectionAssociationDiff
+
+    # : (Hash[identity, RecordSnapshot], Hash[identity, RecordSnapshot]) -> Array[RecordSnapshot]
+    private def self.records_missing_from: (Hash[identity, RecordSnapshot], Hash[identity, RecordSnapshot]) -> Array[RecordSnapshot]
+
+    # : (Hash[identity, RecordSnapshot], Hash[identity, RecordSnapshot]) -> Array[RecordChange]
+    private def self.changed_records: (Hash[identity, RecordSnapshot], Hash[identity, RecordSnapshot]) -> Array[RecordChange]
+
+    # : (Array[RecordSnapshot]) -> Hash[Array[untyped], RecordSnapshot]
+    private def self.index_records: (Array[RecordSnapshot]) -> Hash[Array[untyped], RecordSnapshot]
+
+    # : (Array[Array[untyped]]) -> Array[Array[untyped]]
+    private def self.sorted_identities: (Array[Array[untyped]]) -> Array[Array[untyped]]
+
+    # : (RecordSnapshot?, RecordSnapshot?) -> bool
+    private def self.same_identity?: (RecordSnapshot?, RecordSnapshot?) -> bool
+  end
+end

data/sig/generated/paper_trail_diff/errors.rbs

@@ -0,0 +1,43 @@
+# Generated from lib/paper_trail_diff/errors.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Base error for failures detected by paper_trail_diff.
+  class Error < StandardError
+  end
+
+  # Raised when a public option has an invalid type, key, value, or path.
+  class ConfigurationError < Error
+  end
+
+  # Raised when compare endpoints do not belong to the same PaperTrail item.
+  class VersionMismatchError < Error
+  end
+
+  # Raised when a live endpoint is not a clean, persisted ActiveRecord record.
+  class InvalidEndpointError < Error
+  end
+
+  # Raised when a timeline boundary is absent or the requested range is reversed.
+  class InvalidTimelineRangeError < Error
+  end
+
+  # Raised when a requested ActiveRecord association does not exist.
+  class UnknownAssociationError < Error
+  end
+
+  # Raised when a requested association macro is not supported.
+  class UnsupportedAssociationError < Error
+  end
+
+  # Raised when association comparison is requested without an available PT-AT setup.
+  class AssociationTrackingUnavailableError < Error
+  end
+
+  # Raised when recorded PT-AT metadata cannot reliably reconstruct a selected association.
+  class IncompleteAssociationHistoryError < Error
+  end
+
+  # Raised when current-ended activity cannot be reconstructed for a selected association.
+  class UnsupportedLiveActivityError < Error
+  end
+end

data/sig/generated/paper_trail_diff/historical_association_reifier.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/paper_trail_diff/historical_association_reifier.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Reconstructs selected nested edges at one root PaperTrail endpoint.
+  class HistoricalAssociationReifier
+    # : (untyped, ?habtm_version: untyped) -> void
+    def initialize: (untyped, ?habtm_version: untyped) -> void
+
+    # : (untyped, Array[untyped]) -> void
+    def reify: (untyped, Array[untyped]) -> void
+
+    private
+
+    @habtm_transaction_id: untyped
+
+    @reified_associations: Hash[Array[untyped], bool]
+
+    @transaction_id: untyped
+
+    @version_at: untyped
+
+    # : (untyped, untyped) -> void
+    def reify_association: (untyped, untyped) -> void
+
+    # : (untyped, untyped) -> void
+    def reify_has_many: (untyped, untyped) -> void
+
+    # : (untyped, untyped) -> void
+    def reify_habtm: (untyped, untyped) -> void
+
+    # : () -> Hash[Symbol, untyped]
+    def options: () -> Hash[Symbol, untyped]
+
+    # : (Symbol) -> untyped
+    def reifier: (Symbol) -> untyped
+  end
+end

data/sig/generated/paper_trail_diff/historical_snapshot_store.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/paper_trail_diff/historical_snapshot_store.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Reconstructs and caches immutable historical snapshots for one adapter configuration.
+  class HistoricalSnapshotStore
+    # : (tree: AssociationTree, traversal: AssociationTraversal, normalizer: SnapshotNormalizer, preparer: untyped) -> void
+    def initialize: (tree: AssociationTree, traversal: AssociationTraversal, normalizer: SnapshotNormalizer, preparer: untyped) -> void
+
+    # : (untyped, Array[untyped]) -> void
+    def prepare: (untyped, Array[untyped]) -> void
+
+    # : (untyped, untyped) -> RecordSnapshot?
+    def call: (untyped, untyped) -> RecordSnapshot?
+
+    # : (untyped, untyped) -> RecordSnapshot?
+    def uncached: (untyped, untyped) -> RecordSnapshot?
+
+    # : (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
+    def custom: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
+
+    # : (untyped, habtm_version: untyped) -> untyped
+    def association_reader: (untyped, habtm_version: untyped) -> untyped
+
+    private
+
+    @normalizer: SnapshotNormalizer
+
+    @prepared_history: PreparedHistory?
+
+    @preparer: untyped
+
+    @snapshots: Hash[Array[untyped], RecordSnapshot?]
+
+    @traversal: AssociationTraversal
+
+    @tree: AssociationTree
+
+    # : (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
+    def snapshot_from_version: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
+
+    # : (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
+    def snapshot_from_live_root: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
+
+    # : (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, habtm_version: untyped) -> RecordSnapshot?
+    def normalize: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, habtm_version: untyped) -> RecordSnapshot?
+
+    # : (untyped, untyped) -> Array[untyped]
+    def snapshot_key: (untyped, untyped) -> Array[untyped]
+  end
+end

data/sig/generated/paper_trail_diff/live_association_reader.rbs

@@ -0,0 +1,9 @@
+# Generated from lib/paper_trail_diff/live_association_reader.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Leaves live ActiveRecord associations untouched while sharing snapshot normalization.
+  class LiveAssociationReader
+    # : (untyped, Array[untyped]) -> void
+    def reify: (untyped, Array[untyped]) -> void
+  end
+end

data/sig/generated/paper_trail_diff/paper_trail_adapter.rbs

@@ -0,0 +1,72 @@
+# Generated from lib/paper_trail_diff/paper_trail_adapter.rb with RBS::Inline
+
+module PaperTrailDiff
+  # PaperTrail/ActiveRecord boundary that produces plain record snapshots.
+  class PaperTrailAdapter
+    # : (associations: Array[String | Symbol], ignore: ignore_option) -> void
+    def initialize: (associations: Array[String | Symbol], ignore: ignore_option) -> void
+
+    # : (untyped, untyped) -> Diff
+    def compare: (untyped, untyped) -> Diff
+
+    # : (untyped, from: untyped, to: untyped) -> Array[Step]
+    def timeline: (untyped, from: untyped, to: untyped) -> Array[Step]
+
+    # : (untyped, from: untyped, to: untyped) -> Array[ActivityStep]
+    def activity_timeline: (untyped, from: untyped, to: untyped) -> Array[ActivityStep]
+
+    # : (untyped, from: untyped, to: untyped, ?activity: bool) -> Analysis
+    def analyze: (untyped, from: untyped, to: untyped, ?activity: bool) -> Analysis
+
+    private
+
+    @activity_snapshotter: ActivitySnapshotProvider
+
+    @association_tree: AssociationTree
+
+    @historical_store: HistoricalSnapshotStore
+
+    @ignore_policy: IgnorePolicy
+
+    @normalizer: SnapshotNormalizer
+
+    @snapshot_pool: SnapshotPool
+
+    @timeline_snapshotter: TimelineSnapshotProvider
+
+    @traversal: AssociationTraversal
+
+    # : () -> HistoricalSnapshotStore
+    def build_historical_store: () -> HistoricalSnapshotStore
+
+    # : () -> ActivitySnapshotProvider
+    def build_activity_snapshotter: () -> ActivitySnapshotProvider
+
+    # : (untyped, from: untyped, to: untyped) -> ActivityTimelineBuilder
+    def activity_builder: (untyped, from: untyped, to: untyped) -> ActivityTimelineBuilder
+
+    # : (untyped) -> void
+    def reject_live_habtm_activity!: (untyped) -> void
+
+    # : (untyped) -> RecordSnapshot?
+    def snapshot_for_endpoint: (untyped) -> RecordSnapshot?
+
+    # : (untyped) -> RecordSnapshot?
+    def historical_snapshot: (untyped) -> RecordSnapshot?
+
+    # : (untyped) -> RecordSnapshot?
+    def uncached_historical_snapshot: (untyped) -> RecordSnapshot?
+
+    # : (untyped, untyped) -> RecordSnapshot?
+    def snapshot_at: (untyped, untyped) -> RecordSnapshot?
+
+    # : (untyped) -> RecordSnapshot
+    def live_snapshot: (untyped) -> RecordSnapshot
+
+    # : (untyped, historical: bool) -> void
+    def prepare_traversal!: (untyped, historical: bool) -> void
+
+    # : () -> void
+    def ensure_association_tracking!: () -> void
+  end
+end

data/sig/generated/paper_trail_diff/prepared_association_reifier.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/paper_trail_diff/prepared_association_reifier.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Resolves indexed associations and delegates unsupported reflections to PT-AT.
+  class PreparedAssociationReifier
+    # : (PreparedHistory, untyped, habtm_boundary: untyped, fallback: HistoricalAssociationReifier) -> void
+    def initialize: (PreparedHistory, untyped, habtm_boundary: untyped, fallback: HistoricalAssociationReifier) -> void
+
+    # : (untyped, Array[untyped]) -> void
+    def reify: (untyped, Array[untyped]) -> void
+
+    private
+
+    @boundary: untyped
+
+    @fallback: HistoricalAssociationReifier
+
+    @habtm_boundary: untyped
+
+    @history: PreparedHistory
+
+    @reified: Hash[Array[untyped], bool]
+
+    # : (untyped, untyped) -> void
+    def reify_association: (untyped, untyped) -> void
+  end
+end