lithic 0.1.0.pre.alpha.55 → 0.1.0.pre.alpha.56

data/rbi/lithic/models/dispute.rbi

@@ -6,129 +6,237 @@ module Lithic
       OrHash =
         T.type_alias { T.any(Lithic::Dispute, Lithic::Internal::AnyHash) }
 
-      # Token assigned by Lithic for the dispute, in UUID format.
+      # Globally unique identifier.
       sig { returns(String) }
       attr_accessor :token
 
-      # Token for the account associated with the dispute, in UUID format.
-      sig { returns(String) }
-      attr_accessor :account_token
-
-      # Token for the card used in the dispute, in UUID format.
-      sig { returns(String) }
-      attr_accessor :card_token
+      # Amount under dispute. May be different from the original transaction amount.
+      sig { returns(Integer) }
+      attr_accessor :amount
 
-      # Identifier assigned by the network for this dispute.
-      sig { returns(T.nilable(String)) }
-      attr_accessor :case_id
+      # Date dispute entered arbitration.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :arbitration_date
 
-      # When the dispute was created.
+      # Timestamp of when first Dispute was reported.
       sig { returns(Time) }
       attr_accessor :created
 
-      # Three-letter ISO 4217 currency code.
-      sig { returns(String) }
-      attr_accessor :currency
-
-      # Dispute resolution outcome
-      sig { returns(T.nilable(Lithic::Dispute::Disposition::OrSymbol)) }
-      attr_accessor :disposition
-
-      # Chronological list of events that have occurred in the dispute lifecycle
-      sig { returns(T::Array[Lithic::Dispute::Event]) }
-      attr_accessor :events
-
-      # Current breakdown of how liability is allocated for the disputed amount
-      sig { returns(Lithic::Dispute::LiabilityAllocation) }
-      attr_reader :liability_allocation
-
-      sig do
-        params(
-          liability_allocation: Lithic::Dispute::LiabilityAllocation::OrHash
-        ).void
-      end
-      attr_writer :liability_allocation
+      # Date that the dispute was filed by the customer making the dispute.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :customer_filed_date
 
-      sig { returns(Lithic::Dispute::Merchant) }
-      attr_reader :merchant
+      # End customer description of the reason for the dispute.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_note
 
-      sig { params(merchant: Lithic::Dispute::Merchant::OrHash).void }
-      attr_writer :merchant
+      # Unique identifiers for the dispute from the network.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :network_claim_ids
 
-      # Card network handling the dispute.
-      sig { returns(Lithic::Dispute::Network::OrSymbol) }
-      attr_accessor :network
+      # Date that the dispute was submitted to the network.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :network_filed_date
 
-      # Current status of the dispute.
-      sig { returns(T.nilable(Lithic::Dispute::Status::OrSymbol)) }
-      attr_accessor :status
+      # Network reason code used to file the dispute.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :network_reason_code
 
-      # Contains identifiers for the transaction and specific event within being
-      # disputed; null if no transaction can be identified
-      sig { returns(T.nilable(Lithic::Dispute::TransactionSeries)) }
-      attr_reader :transaction_series
+      # Date dispute entered pre-arbitration.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :prearbitration_date
 
+      # Unique identifier for the dispute from the network. If there are multiple, this
+      # will be the first claim id set by the network
+      sig { returns(T.nilable(String)) }
+      attr_accessor :primary_claim_id
+
+      # Dispute reason:
+      #
+      # - `ATM_CASH_MISDISPENSE`: ATM cash misdispense.
+      # - `CANCELLED`: Transaction was cancelled by the customer.
+      # - `DUPLICATED`: The transaction was a duplicate.
+      # - `FRAUD_CARD_NOT_PRESENT`: Fraudulent transaction, card not present.
+      # - `FRAUD_CARD_PRESENT`: Fraudulent transaction, card present.
+      # - `FRAUD_OTHER`: Fraudulent transaction, other types such as questionable
+      #   merchant activity.
+      # - `GOODS_SERVICES_NOT_AS_DESCRIBED`: The goods or services were not as
+      #   described.
+      # - `GOODS_SERVICES_NOT_RECEIVED`: The goods or services were not received.
+      # - `INCORRECT_AMOUNT`: The transaction amount was incorrect.
+      # - `MISSING_AUTH`: The transaction was missing authorization.
+      # - `OTHER`: Other reason.
+      # - `PROCESSING_ERROR`: Processing error.
+      # - `REFUND_NOT_PROCESSED`: The refund was not processed.
+      # - `RECURRING_TRANSACTION_NOT_CANCELLED`: The recurring transaction was not
+      #   cancelled.
+      sig { returns(Lithic::Dispute::Reason::TaggedSymbol) }
+      attr_accessor :reason
+
+      # Date the representment was received.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :representment_date
+
+      # Date that the dispute was resolved.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :resolution_date
+
+      # Note by Dispute team on the case resolution.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :resolution_note
+
+      # Reason for the dispute resolution:
+      #
+      # - `CASE_LOST`: This case was lost at final arbitration.
+      # - `NETWORK_REJECTED`: Network rejected.
+      # - `NO_DISPUTE_RIGHTS_3DS`: No dispute rights, 3DS.
+      # - `NO_DISPUTE_RIGHTS_BELOW_THRESHOLD`: No dispute rights, below threshold.
+      # - `NO_DISPUTE_RIGHTS_CONTACTLESS`: No dispute rights, contactless.
+      # - `NO_DISPUTE_RIGHTS_HYBRID`: No dispute rights, hybrid.
+      # - `NO_DISPUTE_RIGHTS_MAX_CHARGEBACKS`: No dispute rights, max chargebacks.
+      # - `NO_DISPUTE_RIGHTS_OTHER`: No dispute rights, other.
+      # - `PAST_FILING_DATE`: Past filing date.
+      # - `PREARBITRATION_REJECTED`: Prearbitration rejected.
+      # - `PROCESSOR_REJECTED_OTHER`: Processor rejected, other.
+      # - `REFUNDED`: Refunded.
+      # - `REFUNDED_AFTER_CHARGEBACK`: Refunded after chargeback.
+      # - `WITHDRAWN`: Withdrawn.
+      # - `WON_ARBITRATION`: Won arbitration.
+      # - `WON_FIRST_CHARGEBACK`: Won first chargeback.
+      # - `WON_PREARBITRATION`: Won prearbitration.
       sig do
-        params(
-          transaction_series:
-            T.nilable(Lithic::Dispute::TransactionSeries::OrHash)
-        ).void
+        returns(T.nilable(Lithic::Dispute::ResolutionReason::TaggedSymbol))
       end
-      attr_writer :transaction_series
+      attr_accessor :resolution_reason
+
+      # Status types:
+      #
+      # - `NEW` - New dispute case is opened.
+      # - `PENDING_CUSTOMER` - Lithic is waiting for customer to provide more
+      #   information.
+      # - `SUBMITTED` - Dispute is submitted to the card network.
+      # - `REPRESENTMENT` - Case has entered second presentment.
+      # - `PREARBITRATION` - Case has entered prearbitration.
+      # - `ARBITRATION` - Case has entered arbitration.
+      # - `CASE_WON` - Case was won and credit will be issued.
+      # - `CASE_CLOSED` - Case was lost or withdrawn.
+      sig { returns(Lithic::Dispute::Status::TaggedSymbol) }
+      attr_accessor :status
 
-      # When the dispute was last updated.
-      sig { returns(Time) }
-      attr_accessor :updated
+      # The transaction that is being disputed. A transaction can only be disputed once
+      # but may have multiple dispute cases.
+      sig { returns(String) }
+      attr_accessor :transaction_token
 
-      # The Dispute object tracks the progression of a dispute throughout its lifecycle.
+      # Dispute.
       sig do
         params(
           token: String,
-          account_token: String,
-          card_token: String,
-          case_id: T.nilable(String),
+          amount: Integer,
+          arbitration_date: T.nilable(Time),
           created: Time,
-          currency: String,
-          disposition: T.nilable(Lithic::Dispute::Disposition::OrSymbol),
-          events: T::Array[Lithic::Dispute::Event::OrHash],
-          liability_allocation: Lithic::Dispute::LiabilityAllocation::OrHash,
-          merchant: Lithic::Dispute::Merchant::OrHash,
-          network: Lithic::Dispute::Network::OrSymbol,
-          status: T.nilable(Lithic::Dispute::Status::OrSymbol),
-          transaction_series:
-            T.nilable(Lithic::Dispute::TransactionSeries::OrHash),
-          updated: Time
+          customer_filed_date: T.nilable(Time),
+          customer_note: T.nilable(String),
+          network_claim_ids: T.nilable(T::Array[String]),
+          network_filed_date: T.nilable(Time),
+          network_reason_code: T.nilable(String),
+          prearbitration_date: T.nilable(Time),
+          primary_claim_id: T.nilable(String),
+          reason: Lithic::Dispute::Reason::OrSymbol,
+          representment_date: T.nilable(Time),
+          resolution_date: T.nilable(Time),
+          resolution_note: T.nilable(String),
+          resolution_reason:
+            T.nilable(Lithic::Dispute::ResolutionReason::OrSymbol),
+          status: Lithic::Dispute::Status::OrSymbol,
+          transaction_token: String
         ).returns(T.attached_class)
       end
       def self.new(
-        # Token assigned by Lithic for the dispute, in UUID format.
+        # Globally unique identifier.
         token:,
-        # Token for the account associated with the dispute, in UUID format.
-        account_token:,
-        # Token for the card used in the dispute, in UUID format.
-        card_token:,
-        # Identifier assigned by the network for this dispute.
-        case_id:,
-        # When the dispute was created.
+        # Amount under dispute. May be different from the original transaction amount.
+        amount:,
+        # Date dispute entered arbitration.
+        arbitration_date:,
+        # Timestamp of when first Dispute was reported.
         created:,
-        # Three-letter ISO 4217 currency code.
-        currency:,
-        # Dispute resolution outcome
-        disposition:,
-        # Chronological list of events that have occurred in the dispute lifecycle
-        events:,
-        # Current breakdown of how liability is allocated for the disputed amount
-        liability_allocation:,
-        merchant:,
-        # Card network handling the dispute.
-        network:,
-        # Current status of the dispute.
+        # Date that the dispute was filed by the customer making the dispute.
+        customer_filed_date:,
+        # End customer description of the reason for the dispute.
+        customer_note:,
+        # Unique identifiers for the dispute from the network.
+        network_claim_ids:,
+        # Date that the dispute was submitted to the network.
+        network_filed_date:,
+        # Network reason code used to file the dispute.
+        network_reason_code:,
+        # Date dispute entered pre-arbitration.
+        prearbitration_date:,
+        # Unique identifier for the dispute from the network. If there are multiple, this
+        # will be the first claim id set by the network
+        primary_claim_id:,
+        # Dispute reason:
+        #
+        # - `ATM_CASH_MISDISPENSE`: ATM cash misdispense.
+        # - `CANCELLED`: Transaction was cancelled by the customer.
+        # - `DUPLICATED`: The transaction was a duplicate.
+        # - `FRAUD_CARD_NOT_PRESENT`: Fraudulent transaction, card not present.
+        # - `FRAUD_CARD_PRESENT`: Fraudulent transaction, card present.
+        # - `FRAUD_OTHER`: Fraudulent transaction, other types such as questionable
+        #   merchant activity.
+        # - `GOODS_SERVICES_NOT_AS_DESCRIBED`: The goods or services were not as
+        #   described.
+        # - `GOODS_SERVICES_NOT_RECEIVED`: The goods or services were not received.
+        # - `INCORRECT_AMOUNT`: The transaction amount was incorrect.
+        # - `MISSING_AUTH`: The transaction was missing authorization.
+        # - `OTHER`: Other reason.
+        # - `PROCESSING_ERROR`: Processing error.
+        # - `REFUND_NOT_PROCESSED`: The refund was not processed.
+        # - `RECURRING_TRANSACTION_NOT_CANCELLED`: The recurring transaction was not
+        #   cancelled.
+        reason:,
+        # Date the representment was received.
+        representment_date:,
+        # Date that the dispute was resolved.
+        resolution_date:,
+        # Note by Dispute team on the case resolution.
+        resolution_note:,
+        # Reason for the dispute resolution:
+        #
+        # - `CASE_LOST`: This case was lost at final arbitration.
+        # - `NETWORK_REJECTED`: Network rejected.
+        # - `NO_DISPUTE_RIGHTS_3DS`: No dispute rights, 3DS.
+        # - `NO_DISPUTE_RIGHTS_BELOW_THRESHOLD`: No dispute rights, below threshold.
+        # - `NO_DISPUTE_RIGHTS_CONTACTLESS`: No dispute rights, contactless.
+        # - `NO_DISPUTE_RIGHTS_HYBRID`: No dispute rights, hybrid.
+        # - `NO_DISPUTE_RIGHTS_MAX_CHARGEBACKS`: No dispute rights, max chargebacks.
+        # - `NO_DISPUTE_RIGHTS_OTHER`: No dispute rights, other.
+        # - `PAST_FILING_DATE`: Past filing date.
+        # - `PREARBITRATION_REJECTED`: Prearbitration rejected.
+        # - `PROCESSOR_REJECTED_OTHER`: Processor rejected, other.
+        # - `REFUNDED`: Refunded.
+        # - `REFUNDED_AFTER_CHARGEBACK`: Refunded after chargeback.
+        # - `WITHDRAWN`: Withdrawn.
+        # - `WON_ARBITRATION`: Won arbitration.
+        # - `WON_FIRST_CHARGEBACK`: Won first chargeback.
+        # - `WON_PREARBITRATION`: Won prearbitration.
+        resolution_reason:,
+        # Status types:
+        #
+        # - `NEW` - New dispute case is opened.
+        # - `PENDING_CUSTOMER` - Lithic is waiting for customer to provide more
+        #   information.
+        # - `SUBMITTED` - Dispute is submitted to the card network.
+        # - `REPRESENTMENT` - Case has entered second presentment.
+        # - `PREARBITRATION` - Case has entered prearbitration.
+        # - `ARBITRATION` - Case has entered arbitration.
+        # - `CASE_WON` - Case was won and credit will be issued.
+        # - `CASE_CLOSED` - Case was lost or withdrawn.
         status:,
-        # Contains identifiers for the transaction and specific event within being
-        # disputed; null if no transaction can be identified
-        transaction_series:,
-        # When the dispute was last updated.
-        updated:
+        # The transaction that is being disputed. A transaction can only be disputed once
+        # but may have multiple dispute cases.
+        transaction_token:
       )
       end
 
@@ -136,811 +244,236 @@ module Lithic
         override.returns(
           {
             token: String,
-            account_token: String,
-            card_token: String,
-            case_id: T.nilable(String),
+            amount: Integer,
+            arbitration_date: T.nilable(Time),
             created: Time,
-            currency: String,
-            disposition: T.nilable(Lithic::Dispute::Disposition::OrSymbol),
-            events: T::Array[Lithic::Dispute::Event],
-            liability_allocation: Lithic::Dispute::LiabilityAllocation,
-            merchant: Lithic::Dispute::Merchant,
-            network: Lithic::Dispute::Network::OrSymbol,
-            status: T.nilable(Lithic::Dispute::Status::OrSymbol),
-            transaction_series: T.nilable(Lithic::Dispute::TransactionSeries),
-            updated: Time
+            customer_filed_date: T.nilable(Time),
+            customer_note: T.nilable(String),
+            network_claim_ids: T.nilable(T::Array[String]),
+            network_filed_date: T.nilable(Time),
+            network_reason_code: T.nilable(String),
+            prearbitration_date: T.nilable(Time),
+            primary_claim_id: T.nilable(String),
+            reason: Lithic::Dispute::Reason::TaggedSymbol,
+            representment_date: T.nilable(Time),
+            resolution_date: T.nilable(Time),
+            resolution_note: T.nilable(String),
+            resolution_reason:
+              T.nilable(Lithic::Dispute::ResolutionReason::TaggedSymbol),
+            status: Lithic::Dispute::Status::TaggedSymbol,
+            transaction_token: String
           }
         )
       end
       def to_hash
       end
 
-      # Dispute resolution outcome
-      module Disposition
+      # Dispute reason:
+      #
+      # - `ATM_CASH_MISDISPENSE`: ATM cash misdispense.
+      # - `CANCELLED`: Transaction was cancelled by the customer.
+      # - `DUPLICATED`: The transaction was a duplicate.
+      # - `FRAUD_CARD_NOT_PRESENT`: Fraudulent transaction, card not present.
+      # - `FRAUD_CARD_PRESENT`: Fraudulent transaction, card present.
+      # - `FRAUD_OTHER`: Fraudulent transaction, other types such as questionable
+      #   merchant activity.
+      # - `GOODS_SERVICES_NOT_AS_DESCRIBED`: The goods or services were not as
+      #   described.
+      # - `GOODS_SERVICES_NOT_RECEIVED`: The goods or services were not received.
+      # - `INCORRECT_AMOUNT`: The transaction amount was incorrect.
+      # - `MISSING_AUTH`: The transaction was missing authorization.
+      # - `OTHER`: Other reason.
+      # - `PROCESSING_ERROR`: Processing error.
+      # - `REFUND_NOT_PROCESSED`: The refund was not processed.
+      # - `RECURRING_TRANSACTION_NOT_CANCELLED`: The recurring transaction was not
+      #   cancelled.
+      module Reason
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol =
-          T.type_alias { T.all(Symbol, Lithic::Dispute::Disposition) }
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Dispute::Reason) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        WON = T.let(:WON, Lithic::Dispute::Disposition::TaggedSymbol)
-        LOST = T.let(:LOST, Lithic::Dispute::Disposition::TaggedSymbol)
-        PARTIALLY_WON =
-          T.let(:PARTIALLY_WON, Lithic::Dispute::Disposition::TaggedSymbol)
-        WITHDRAWN =
-          T.let(:WITHDRAWN, Lithic::Dispute::Disposition::TaggedSymbol)
-        DENIED = T.let(:DENIED, Lithic::Dispute::Disposition::TaggedSymbol)
+        ATM_CASH_MISDISPENSE =
+          T.let(:ATM_CASH_MISDISPENSE, Lithic::Dispute::Reason::TaggedSymbol)
+        CANCELLED = T.let(:CANCELLED, Lithic::Dispute::Reason::TaggedSymbol)
+        DUPLICATED = T.let(:DUPLICATED, Lithic::Dispute::Reason::TaggedSymbol)
+        FRAUD_CARD_NOT_PRESENT =
+          T.let(:FRAUD_CARD_NOT_PRESENT, Lithic::Dispute::Reason::TaggedSymbol)
+        FRAUD_CARD_PRESENT =
+          T.let(:FRAUD_CARD_PRESENT, Lithic::Dispute::Reason::TaggedSymbol)
+        FRAUD_OTHER = T.let(:FRAUD_OTHER, Lithic::Dispute::Reason::TaggedSymbol)
+        GOODS_SERVICES_NOT_AS_DESCRIBED =
+          T.let(
+            :GOODS_SERVICES_NOT_AS_DESCRIBED,
+            Lithic::Dispute::Reason::TaggedSymbol
+          )
+        GOODS_SERVICES_NOT_RECEIVED =
+          T.let(
+            :GOODS_SERVICES_NOT_RECEIVED,
+            Lithic::Dispute::Reason::TaggedSymbol
+          )
+        INCORRECT_AMOUNT =
+          T.let(:INCORRECT_AMOUNT, Lithic::Dispute::Reason::TaggedSymbol)
+        MISSING_AUTH =
+          T.let(:MISSING_AUTH, Lithic::Dispute::Reason::TaggedSymbol)
+        OTHER = T.let(:OTHER, Lithic::Dispute::Reason::TaggedSymbol)
+        PROCESSING_ERROR =
+          T.let(:PROCESSING_ERROR, Lithic::Dispute::Reason::TaggedSymbol)
+        RECURRING_TRANSACTION_NOT_CANCELLED =
+          T.let(
+            :RECURRING_TRANSACTION_NOT_CANCELLED,
+            Lithic::Dispute::Reason::TaggedSymbol
+          )
+        REFUND_NOT_PROCESSED =
+          T.let(:REFUND_NOT_PROCESSED, Lithic::Dispute::Reason::TaggedSymbol)
 
         sig do
-          override.returns(T::Array[Lithic::Dispute::Disposition::TaggedSymbol])
+          override.returns(T::Array[Lithic::Dispute::Reason::TaggedSymbol])
         end
         def self.values
         end
       end
 
-      class Event < Lithic::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Lithic::Dispute::Event, Lithic::Internal::AnyHash)
-          end
-
-        # Unique identifier for the event, in UUID format
-        sig { returns(String) }
-        attr_accessor :token
+      # Reason for the dispute resolution:
+      #
+      # - `CASE_LOST`: This case was lost at final arbitration.
+      # - `NETWORK_REJECTED`: Network rejected.
+      # - `NO_DISPUTE_RIGHTS_3DS`: No dispute rights, 3DS.
+      # - `NO_DISPUTE_RIGHTS_BELOW_THRESHOLD`: No dispute rights, below threshold.
+      # - `NO_DISPUTE_RIGHTS_CONTACTLESS`: No dispute rights, contactless.
+      # - `NO_DISPUTE_RIGHTS_HYBRID`: No dispute rights, hybrid.
+      # - `NO_DISPUTE_RIGHTS_MAX_CHARGEBACKS`: No dispute rights, max chargebacks.
+      # - `NO_DISPUTE_RIGHTS_OTHER`: No dispute rights, other.
+      # - `PAST_FILING_DATE`: Past filing date.
+      # - `PREARBITRATION_REJECTED`: Prearbitration rejected.
+      # - `PROCESSOR_REJECTED_OTHER`: Processor rejected, other.
+      # - `REFUNDED`: Refunded.
+      # - `REFUNDED_AFTER_CHARGEBACK`: Refunded after chargeback.
+      # - `WITHDRAWN`: Withdrawn.
+      # - `WON_ARBITRATION`: Won arbitration.
+      # - `WON_FIRST_CHARGEBACK`: Won first chargeback.
+      # - `WON_PREARBITRATION`: Won prearbitration.
+      module ResolutionReason
+        extend Lithic::Internal::Type::Enum
 
-        # When the event occurred
-        sig { returns(Time) }
-        attr_accessor :created
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Dispute::ResolutionReason) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        # Details specific to the event type
-        sig do
-          returns(
-            T.any(
-              Lithic::Dispute::Event::Data::WorkflowEventData,
-              Lithic::Dispute::Event::Data::FinancialEventData,
-              Lithic::Dispute::Event::Data::CardholderLiabilityEventData
-            )
+        CASE_LOST =
+          T.let(:CASE_LOST, Lithic::Dispute::ResolutionReason::TaggedSymbol)
+        NETWORK_REJECTED =
+          T.let(
+            :NETWORK_REJECTED,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
           )
-        end
-        attr_accessor :data
-
-        # Type of event
-        sig { returns(Lithic::Dispute::Event::Type::OrSymbol) }
-        attr_accessor :type
-
-        # Event that occurred in the dispute lifecycle
-        sig do
-          params(
-            token: String,
-            created: Time,
-            data:
-              T.any(
-                Lithic::Dispute::Event::Data::WorkflowEventData::OrHash,
-                Lithic::Dispute::Event::Data::FinancialEventData::OrHash,
-                Lithic::Dispute::Event::Data::CardholderLiabilityEventData::OrHash
-              ),
-            type: Lithic::Dispute::Event::Type::OrSymbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Unique identifier for the event, in UUID format
-          token:,
-          # When the event occurred
-          created:,
-          # Details specific to the event type
-          data:,
-          # Type of event
-          type:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              token: String,
-              created: Time,
-              data:
-                T.any(
-                  Lithic::Dispute::Event::Data::WorkflowEventData,
-                  Lithic::Dispute::Event::Data::FinancialEventData,
-                  Lithic::Dispute::Event::Data::CardholderLiabilityEventData
-                ),
-              type: Lithic::Dispute::Event::Type::OrSymbol
-            }
+        NO_DISPUTE_RIGHTS_3DS =
+          T.let(
+            :NO_DISPUTE_RIGHTS_3DS,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
           )
-        end
-        def to_hash
-        end
-
-        # Details specific to the event type
-        module Data
-          extend Lithic::Internal::Type::Union
-
-          Variants =
-            T.type_alias do
-              T.any(
-                Lithic::Dispute::Event::Data::WorkflowEventData,
-                Lithic::Dispute::Event::Data::FinancialEventData,
-                Lithic::Dispute::Event::Data::CardholderLiabilityEventData
-              )
-            end
-
-          class WorkflowEventData < Lithic::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Lithic::Dispute::Event::Data::WorkflowEventData,
-                  Lithic::Internal::AnyHash
-                )
-              end
-
-            # Action taken in this stage
-            sig do
-              returns(
-                Lithic::Dispute::Event::Data::WorkflowEventData::Action::OrSymbol
-              )
-            end
-            attr_accessor :action
-
-            # Amount in minor units
-            sig { returns(T.nilable(Integer)) }
-            attr_accessor :amount
-
-            # Dispute resolution outcome
-            sig do
-              returns(
-                T.nilable(
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Disposition::OrSymbol
-                )
-              )
-            end
-            attr_accessor :disposition
-
-            # Reason for the action
-            sig { returns(T.nilable(String)) }
-            attr_accessor :reason
-
-            # Current stage of the dispute workflow
-            sig do
-              returns(
-                Lithic::Dispute::Event::Data::WorkflowEventData::Stage::OrSymbol
-              )
-            end
-            attr_accessor :stage
-
-            # Details specific to workflow events
-            sig do
-              params(
-                action:
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Action::OrSymbol,
-                amount: T.nilable(Integer),
-                disposition:
-                  T.nilable(
-                    Lithic::Dispute::Event::Data::WorkflowEventData::Disposition::OrSymbol
-                  ),
-                reason: T.nilable(String),
-                stage:
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Stage::OrSymbol
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # Action taken in this stage
-              action:,
-              # Amount in minor units
-              amount:,
-              # Dispute resolution outcome
-              disposition:,
-              # Reason for the action
-              reason:,
-              # Current stage of the dispute workflow
-              stage:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  action:
-                    Lithic::Dispute::Event::Data::WorkflowEventData::Action::OrSymbol,
-                  amount: T.nilable(Integer),
-                  disposition:
-                    T.nilable(
-                      Lithic::Dispute::Event::Data::WorkflowEventData::Disposition::OrSymbol
-                    ),
-                  reason: T.nilable(String),
-                  stage:
-                    Lithic::Dispute::Event::Data::WorkflowEventData::Stage::OrSymbol
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # Action taken in this stage
-            module Action
-              extend Lithic::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Lithic::Dispute::Event::Data::WorkflowEventData::Action
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              OPENED =
-                T.let(
-                  :OPENED,
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Action::TaggedSymbol
-                )
-              CLOSED =
-                T.let(
-                  :CLOSED,
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Action::TaggedSymbol
-                )
-              REOPENED =
-                T.let(
-                  :REOPENED,
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Action::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Lithic::Dispute::Event::Data::WorkflowEventData::Action::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Dispute resolution outcome
-            module Disposition
-              extend Lithic::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Lithic::Dispute::Event::Data::WorkflowEventData::Disposition
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              WON =
-                T.let(
-                  :WON,
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Disposition::TaggedSymbol
-                )
-              LOST =
-                T.let(
-                  :LOST,
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Disposition::TaggedSymbol
-                )
-              PARTIALLY_WON =
-                T.let(
-                  :PARTIALLY_WON,
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Disposition::TaggedSymbol
-                )
-              WITHDRAWN =
-                T.let(
-                  :WITHDRAWN,
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Disposition::TaggedSymbol
-                )
-              DENIED =
-                T.let(
-                  :DENIED,
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Disposition::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Lithic::Dispute::Event::Data::WorkflowEventData::Disposition::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Current stage of the dispute workflow
-            module Stage
-              extend Lithic::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Lithic::Dispute::Event::Data::WorkflowEventData::Stage
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              CLAIM =
-                T.let(
-                  :CLAIM,
-                  Lithic::Dispute::Event::Data::WorkflowEventData::Stage::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Lithic::Dispute::Event::Data::WorkflowEventData::Stage::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-
-          class FinancialEventData < Lithic::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Lithic::Dispute::Event::Data::FinancialEventData,
-                  Lithic::Internal::AnyHash
-                )
-              end
-
-            # Amount in minor units
-            sig { returns(Integer) }
-            attr_accessor :amount
-
-            # Direction of funds flow
-            sig do
-              returns(
-                Lithic::Dispute::Event::Data::FinancialEventData::Polarity::OrSymbol
-              )
-            end
-            attr_accessor :polarity
-
-            # Stage at which the financial event occurred
-            sig do
-              returns(
-                Lithic::Dispute::Event::Data::FinancialEventData::Stage::OrSymbol
-              )
-            end
-            attr_accessor :stage
-
-            # Details specific to financial events
-            sig do
-              params(
-                amount: Integer,
-                polarity:
-                  Lithic::Dispute::Event::Data::FinancialEventData::Polarity::OrSymbol,
-                stage:
-                  Lithic::Dispute::Event::Data::FinancialEventData::Stage::OrSymbol
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # Amount in minor units
-              amount:,
-              # Direction of funds flow
-              polarity:,
-              # Stage at which the financial event occurred
-              stage:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  amount: Integer,
-                  polarity:
-                    Lithic::Dispute::Event::Data::FinancialEventData::Polarity::OrSymbol,
-                  stage:
-                    Lithic::Dispute::Event::Data::FinancialEventData::Stage::OrSymbol
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # Direction of funds flow
-            module Polarity
-              extend Lithic::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Lithic::Dispute::Event::Data::FinancialEventData::Polarity
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              CREDIT =
-                T.let(
-                  :CREDIT,
-                  Lithic::Dispute::Event::Data::FinancialEventData::Polarity::TaggedSymbol
-                )
-              DEBIT =
-                T.let(
-                  :DEBIT,
-                  Lithic::Dispute::Event::Data::FinancialEventData::Polarity::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Lithic::Dispute::Event::Data::FinancialEventData::Polarity::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Stage at which the financial event occurred
-            module Stage
-              extend Lithic::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Lithic::Dispute::Event::Data::FinancialEventData::Stage
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              CHARGEBACK =
-                T.let(
-                  :CHARGEBACK,
-                  Lithic::Dispute::Event::Data::FinancialEventData::Stage::TaggedSymbol
-                )
-              REPRESENTMENT =
-                T.let(
-                  :REPRESENTMENT,
-                  Lithic::Dispute::Event::Data::FinancialEventData::Stage::TaggedSymbol
-                )
-              PREARBITRATION =
-                T.let(
-                  :PREARBITRATION,
-                  Lithic::Dispute::Event::Data::FinancialEventData::Stage::TaggedSymbol
-                )
-              ARBITRATION =
-                T.let(
-                  :ARBITRATION,
-                  Lithic::Dispute::Event::Data::FinancialEventData::Stage::TaggedSymbol
-                )
-              COLLABORATION =
-                T.let(
-                  :COLLABORATION,
-                  Lithic::Dispute::Event::Data::FinancialEventData::Stage::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Lithic::Dispute::Event::Data::FinancialEventData::Stage::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-
-          class CardholderLiabilityEventData < Lithic::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Lithic::Dispute::Event::Data::CardholderLiabilityEventData,
-                  Lithic::Internal::AnyHash
-                )
-              end
-
-            # Action taken regarding cardholder liability
-            sig do
-              returns(
-                Lithic::Dispute::Event::Data::CardholderLiabilityEventData::Action::OrSymbol
-              )
-            end
-            attr_accessor :action
-
-            # Amount in minor units
-            sig { returns(Integer) }
-            attr_accessor :amount
-
-            # Reason for the action
-            sig { returns(String) }
-            attr_accessor :reason
-
-            # Details specific to cardholder liability events
-            sig do
-              params(
-                action:
-                  Lithic::Dispute::Event::Data::CardholderLiabilityEventData::Action::OrSymbol,
-                amount: Integer,
-                reason: String
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # Action taken regarding cardholder liability
-              action:,
-              # Amount in minor units
-              amount:,
-              # Reason for the action
-              reason:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  action:
-                    Lithic::Dispute::Event::Data::CardholderLiabilityEventData::Action::OrSymbol,
-                  amount: Integer,
-                  reason: String
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # Action taken regarding cardholder liability
-            module Action
-              extend Lithic::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Lithic::Dispute::Event::Data::CardholderLiabilityEventData::Action
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              PROVISIONAL_CREDIT_GRANTED =
-                T.let(
-                  :PROVISIONAL_CREDIT_GRANTED,
-                  Lithic::Dispute::Event::Data::CardholderLiabilityEventData::Action::TaggedSymbol
-                )
-              PROVISIONAL_CREDIT_REVERSED =
-                T.let(
-                  :PROVISIONAL_CREDIT_REVERSED,
-                  Lithic::Dispute::Event::Data::CardholderLiabilityEventData::Action::TaggedSymbol
-                )
-              WRITTEN_OFF =
-                T.let(
-                  :WRITTEN_OFF,
-                  Lithic::Dispute::Event::Data::CardholderLiabilityEventData::Action::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Lithic::Dispute::Event::Data::CardholderLiabilityEventData::Action::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-
-          sig do
-            override.returns(T::Array[Lithic::Dispute::Event::Data::Variants])
-          end
-          def self.variants
-          end
-        end
-
-        # Type of event
-        module Type
-          extend Lithic::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias { T.all(Symbol, Lithic::Dispute::Event::Type) }
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          WORKFLOW =
-            T.let(:WORKFLOW, Lithic::Dispute::Event::Type::TaggedSymbol)
-          FINANCIAL =
-            T.let(:FINANCIAL, Lithic::Dispute::Event::Type::TaggedSymbol)
-          CARDHOLDER_LIABILITY =
-            T.let(
-              :CARDHOLDER_LIABILITY,
-              Lithic::Dispute::Event::Type::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[Lithic::Dispute::Event::Type::TaggedSymbol]
-            )
-          end
-          def self.values
-          end
-        end
-      end
-
-      class LiabilityAllocation < Lithic::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Lithic::Dispute::LiabilityAllocation,
-              Lithic::Internal::AnyHash
-            )
-          end
-
-        # The amount that has been denied to the cardholder
-        sig { returns(Integer) }
-        attr_accessor :denied_amount
-
-        # The initial amount disputed
-        sig { returns(Integer) }
-        attr_accessor :original_amount
-
-        # The amount that has been recovered from the merchant through the dispute process
-        sig { returns(Integer) }
-        attr_accessor :recovered_amount
-
-        # Any disputed amount that is still outstanding, i.e. has not been recovered,
-        # written off, or denied
-        sig { returns(Integer) }
-        attr_accessor :remaining_amount
-
-        # The amount the issuer has chosen to write off
-        sig { returns(Integer) }
-        attr_accessor :written_off_amount
-
-        # Current breakdown of how liability is allocated for the disputed amount
-        sig do
-          params(
-            denied_amount: Integer,
-            original_amount: Integer,
-            recovered_amount: Integer,
-            remaining_amount: Integer,
-            written_off_amount: Integer
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The amount that has been denied to the cardholder
-          denied_amount:,
-          # The initial amount disputed
-          original_amount:,
-          # The amount that has been recovered from the merchant through the dispute process
-          recovered_amount:,
-          # Any disputed amount that is still outstanding, i.e. has not been recovered,
-          # written off, or denied
-          remaining_amount:,
-          # The amount the issuer has chosen to write off
-          written_off_amount:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              denied_amount: Integer,
-              original_amount: Integer,
-              recovered_amount: Integer,
-              remaining_amount: Integer,
-              written_off_amount: Integer
-            }
+        NO_DISPUTE_RIGHTS_BELOW_THRESHOLD =
+          T.let(
+            :NO_DISPUTE_RIGHTS_BELOW_THRESHOLD,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        NO_DISPUTE_RIGHTS_CONTACTLESS =
+          T.let(
+            :NO_DISPUTE_RIGHTS_CONTACTLESS,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        NO_DISPUTE_RIGHTS_HYBRID =
+          T.let(
+            :NO_DISPUTE_RIGHTS_HYBRID,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        NO_DISPUTE_RIGHTS_MAX_CHARGEBACKS =
+          T.let(
+            :NO_DISPUTE_RIGHTS_MAX_CHARGEBACKS,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        NO_DISPUTE_RIGHTS_OTHER =
+          T.let(
+            :NO_DISPUTE_RIGHTS_OTHER,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        PAST_FILING_DATE =
+          T.let(
+            :PAST_FILING_DATE,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        PREARBITRATION_REJECTED =
+          T.let(
+            :PREARBITRATION_REJECTED,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        PROCESSOR_REJECTED_OTHER =
+          T.let(
+            :PROCESSOR_REJECTED_OTHER,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        REFUNDED =
+          T.let(:REFUNDED, Lithic::Dispute::ResolutionReason::TaggedSymbol)
+        REFUNDED_AFTER_CHARGEBACK =
+          T.let(
+            :REFUNDED_AFTER_CHARGEBACK,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        WITHDRAWN =
+          T.let(:WITHDRAWN, Lithic::Dispute::ResolutionReason::TaggedSymbol)
+        WON_ARBITRATION =
+          T.let(
+            :WON_ARBITRATION,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        WON_FIRST_CHARGEBACK =
+          T.let(
+            :WON_FIRST_CHARGEBACK,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
+          )
+        WON_PREARBITRATION =
+          T.let(
+            :WON_PREARBITRATION,
+            Lithic::Dispute::ResolutionReason::TaggedSymbol
           )
-        end
-        def to_hash
-        end
-      end
-
-      class Merchant < Lithic::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Lithic::Dispute::Merchant, Lithic::Internal::AnyHash)
-          end
-
-        # Unique alphanumeric identifier for the payment card acceptor (merchant).
-        sig { returns(String) }
-        attr_accessor :acceptor_id
-
-        # Unique numeric identifier of the acquiring institution.
-        sig { returns(String) }
-        attr_accessor :acquiring_institution_id
-
-        # City of card acceptor. Note that in many cases, particularly in card-not-present
-        # transactions, merchants may send through a phone number or URL in this field.
-        sig { returns(String) }
-        attr_accessor :city
-
-        # Country or entity of card acceptor. Possible values are: (1) all ISO 3166-1
-        # alpha-3 country codes, (2) QZZ for Kosovo, and (3) ANT for Netherlands Antilles.
-        sig { returns(String) }
-        attr_accessor :country
-
-        # Short description of card acceptor.
-        sig { returns(String) }
-        attr_accessor :descriptor
-
-        # Merchant category code (MCC). A four-digit number listed in ISO 18245. An MCC is
-        # used to classify a business by the types of goods or services it provides.
-        sig { returns(String) }
-        attr_accessor :mcc
-
-        # Geographic state of card acceptor.
-        sig { returns(String) }
-        attr_accessor :state
-
-        sig do
-          params(
-            acceptor_id: String,
-            acquiring_institution_id: String,
-            city: String,
-            country: String,
-            descriptor: String,
-            mcc: String,
-            state: String
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Unique alphanumeric identifier for the payment card acceptor (merchant).
-          acceptor_id:,
-          # Unique numeric identifier of the acquiring institution.
-          acquiring_institution_id:,
-          # City of card acceptor. Note that in many cases, particularly in card-not-present
-          # transactions, merchants may send through a phone number or URL in this field.
-          city:,
-          # Country or entity of card acceptor. Possible values are: (1) all ISO 3166-1
-          # alpha-3 country codes, (2) QZZ for Kosovo, and (3) ANT for Netherlands Antilles.
-          country:,
-          # Short description of card acceptor.
-          descriptor:,
-          # Merchant category code (MCC). A four-digit number listed in ISO 18245. An MCC is
-          # used to classify a business by the types of goods or services it provides.
-          mcc:,
-          # Geographic state of card acceptor.
-          state:
-        )
-        end
 
         sig do
           override.returns(
-            {
-              acceptor_id: String,
-              acquiring_institution_id: String,
-              city: String,
-              country: String,
-              descriptor: String,
-              mcc: String,
-              state: String
-            }
+            T::Array[Lithic::Dispute::ResolutionReason::TaggedSymbol]
           )
         end
-        def to_hash
-        end
-      end
-
-      # Card network handling the dispute.
-      module Network
-        extend Lithic::Internal::Type::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Dispute::Network) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        VISA = T.let(:VISA, Lithic::Dispute::Network::TaggedSymbol)
-        MASTERCARD = T.let(:MASTERCARD, Lithic::Dispute::Network::TaggedSymbol)
-
-        sig do
-          override.returns(T::Array[Lithic::Dispute::Network::TaggedSymbol])
-        end
         def self.values
         end
       end
 
-      # Current status of the dispute.
+      # Status types:
+      #
+      # - `NEW` - New dispute case is opened.
+      # - `PENDING_CUSTOMER` - Lithic is waiting for customer to provide more
+      #   information.
+      # - `SUBMITTED` - Dispute is submitted to the card network.
+      # - `REPRESENTMENT` - Case has entered second presentment.
+      # - `PREARBITRATION` - Case has entered prearbitration.
+      # - `ARBITRATION` - Case has entered arbitration.
+      # - `CASE_WON` - Case was won and credit will be issued.
+      # - `CASE_CLOSED` - Case was lost or withdrawn.
       module Status
         extend Lithic::Internal::Type::Enum
 
         TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Dispute::Status) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        OPEN = T.let(:OPEN, Lithic::Dispute::Status::TaggedSymbol)
-        CLOSED = T.let(:CLOSED, Lithic::Dispute::Status::TaggedSymbol)
+        ARBITRATION = T.let(:ARBITRATION, Lithic::Dispute::Status::TaggedSymbol)
+        CASE_CLOSED = T.let(:CASE_CLOSED, Lithic::Dispute::Status::TaggedSymbol)
+        CASE_WON = T.let(:CASE_WON, Lithic::Dispute::Status::TaggedSymbol)
+        NEW = T.let(:NEW, Lithic::Dispute::Status::TaggedSymbol)
+        PENDING_CUSTOMER =
+          T.let(:PENDING_CUSTOMER, Lithic::Dispute::Status::TaggedSymbol)
+        PREARBITRATION =
+          T.let(:PREARBITRATION, Lithic::Dispute::Status::TaggedSymbol)
+        REPRESENTMENT =
+          T.let(:REPRESENTMENT, Lithic::Dispute::Status::TaggedSymbol)
+        SUBMITTED = T.let(:SUBMITTED, Lithic::Dispute::Status::TaggedSymbol)
 
         sig do
           override.returns(T::Array[Lithic::Dispute::Status::TaggedSymbol])
@@ -948,86 +481,6 @@ module Lithic
         def self.values
         end
       end
-
-      class TransactionSeries < Lithic::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Lithic::Dispute::TransactionSeries, Lithic::Internal::AnyHash)
-          end
-
-        # Token of the specific event in the original transaction being disputed, in UUID
-        # format; null if no event can be identified
-        sig { returns(T.nilable(String)) }
-        attr_accessor :related_transaction_event_token
-
-        # Token of the original transaction being disputed, in UUID format
-        sig { returns(String) }
-        attr_accessor :related_transaction_token
-
-        # The type of transaction series associating the dispute and the original
-        # transaction. Always set to DISPUTE
-        sig { returns(Lithic::Dispute::TransactionSeries::Type::OrSymbol) }
-        attr_accessor :type
-
-        # Contains identifiers for the transaction and specific event within being
-        # disputed; null if no transaction can be identified
-        sig do
-          params(
-            related_transaction_event_token: T.nilable(String),
-            related_transaction_token: String,
-            type: Lithic::Dispute::TransactionSeries::Type::OrSymbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Token of the specific event in the original transaction being disputed, in UUID
-          # format; null if no event can be identified
-          related_transaction_event_token:,
-          # Token of the original transaction being disputed, in UUID format
-          related_transaction_token:,
-          # The type of transaction series associating the dispute and the original
-          # transaction. Always set to DISPUTE
-          type:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              related_transaction_event_token: T.nilable(String),
-              related_transaction_token: String,
-              type: Lithic::Dispute::TransactionSeries::Type::OrSymbol
-            }
-          )
-        end
-        def to_hash
-        end
-
-        # The type of transaction series associating the dispute and the original
-        # transaction. Always set to DISPUTE
-        module Type
-          extend Lithic::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, Lithic::Dispute::TransactionSeries::Type)
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          DISPUTE =
-            T.let(
-              :DISPUTE,
-              Lithic::Dispute::TransactionSeries::Type::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[Lithic::Dispute::TransactionSeries::Type::TaggedSymbol]
-            )
-          end
-          def self.values
-          end
-        end
-      end
     end
   end
 end