lithic 0.14.0 → 0.16.0

data/rbi/lithic/models/payment.rbi

@@ -97,6 +97,14 @@ module Lithic
       sig { returns(T.nilable(String)) }
       attr_accessor :external_bank_account_token
 
+      # Key-value pairs for tagging resources. Tags allow you to associate arbitrary
+      # metadata with a resource for your own purposes.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :tags
+
+      sig { params(tags: T::Hash[Symbol, String]).void }
+      attr_writer :tags
+
       sig { returns(T.nilable(Lithic::Payment::Type::TaggedSymbol)) }
       attr_reader :type
 
@@ -134,6 +142,7 @@ module Lithic
           currency: String,
           expected_release_date: T.nilable(Date),
           external_bank_account_token: T.nilable(String),
+          tags: T::Hash[Symbol, String],
           type: Lithic::Payment::Type::OrSymbol,
           user_defined_id: T.nilable(String),
           family: Symbol
@@ -178,6 +187,9 @@ module Lithic
         expected_release_date: nil,
         # External bank account token
         external_bank_account_token: nil,
+        # Key-value pairs for tagging resources. Tags allow you to associate arbitrary
+        # metadata with a resource for your own purposes.
+        tags: nil,
         type: nil,
         # User-defined identifier
         user_defined_id: nil,
@@ -210,6 +222,7 @@ module Lithic
             currency: String,
             expected_release_date: T.nilable(Date),
             external_bank_account_token: T.nilable(String),
+            tags: T::Hash[Symbol, String],
             type: Lithic::Payment::Type::TaggedSymbol,
             user_defined_id: T.nilable(String)
           }

data/rbi/lithic/models/settlement_detail.rbi

@@ -14,17 +14,17 @@ module Lithic
 
       # Globally unique identifier denoting the account that the associated transaction
       # occurred on.
-      sig { returns(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :account_token
 
       # Globally unique identifier denoting the card program that the associated
       # transaction occurred on.
-      sig { returns(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :card_program_token
 
       # Globally unique identifier denoting the card that the associated transaction
       # occurred on.
-      sig { returns(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :card_token
 
       # Date and time when the transaction first occurred. UTC time zone.
@@ -87,12 +87,12 @@ module Lithic
       attr_accessor :settlement_date
 
       # Globally unique identifier denoting the associated transaction. For settlement
-      # records with type `CLEARING`, `FINANCIAL`, or `NON-FINANCIAL`, this references a
+      # records with type `CLEARING`, `FINANCIAL`, or `NON_FINANCIAL`, this references a
       # card transaction token. For settlement records with type `CHARGEBACK`,
       # `REPRESENTMENT`, `PREARBITRATION`, `ARBITRATION`, or `COLLABORATION`, this
       # references the dispute transaction token. May be null for certain settlement
       # types.
-      sig { returns(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :transaction_token
 
       # The total amount of settlement impacting transactions (excluding interchange,
@@ -118,9 +118,9 @@ module Lithic
       sig do
         params(
           token: String,
-          account_token: String,
-          card_program_token: String,
-          card_token: String,
+          account_token: T.nilable(String),
+          card_program_token: T.nilable(String),
+          card_token: T.nilable(String),
           created: Time,
           currency: String,
           disputes_gross_amount: Integer,
@@ -134,7 +134,7 @@ module Lithic
           other_fees_gross_amount: Integer,
           report_date: String,
           settlement_date: String,
-          transaction_token: String,
+          transaction_token: T.nilable(String),
           transactions_gross_amount: Integer,
           type: Lithic::SettlementDetail::Type::OrSymbol,
           updated: Time,
@@ -182,7 +182,7 @@ module Lithic
         # advisement date, which is distinct from the date of money movement.
         settlement_date:,
         # Globally unique identifier denoting the associated transaction. For settlement
-        # records with type `CLEARING`, `FINANCIAL`, or `NON-FINANCIAL`, this references a
+        # records with type `CLEARING`, `FINANCIAL`, or `NON_FINANCIAL`, this references a
         # card transaction token. For settlement records with type `CHARGEBACK`,
         # `REPRESENTMENT`, `PREARBITRATION`, `ARBITRATION`, or `COLLABORATION`, this
         # references the dispute transaction token. May be null for certain settlement
@@ -204,9 +204,9 @@ module Lithic
         override.returns(
           {
             token: String,
-            account_token: String,
-            card_program_token: String,
-            card_token: String,
+            account_token: T.nilable(String),
+            card_program_token: T.nilable(String),
+            card_token: T.nilable(String),
             created: Time,
             currency: String,
             disputes_gross_amount: Integer,
@@ -219,7 +219,7 @@ module Lithic
             other_fees_gross_amount: Integer,
             report_date: String,
             settlement_date: String,
-            transaction_token: String,
+            transaction_token: T.nilable(String),
             transactions_gross_amount: Integer,
             type: Lithic::SettlementDetail::Type::TaggedSymbol,
             updated: Time,
@@ -305,7 +305,7 @@ module Lithic
         FINANCIAL =
           T.let(:FINANCIAL, Lithic::SettlementDetail::Type::TaggedSymbol)
         NON_FINANCIAL =
-          T.let(:"NON-FINANCIAL", Lithic::SettlementDetail::Type::TaggedSymbol)
+          T.let(:NON_FINANCIAL, Lithic::SettlementDetail::Type::TaggedSymbol)
         PREARBITRATION =
           T.let(:PREARBITRATION, Lithic::SettlementDetail::Type::TaggedSymbol)
         REPRESENTMENT =

data/rbi/lithic/models/statement_totals.rbi

@@ -43,24 +43,15 @@ module Lithic
 
       # Breakdown of credits
       sig { returns(T.nilable(T.anything)) }
-      attr_reader :credit_details
-
-      sig { params(credit_details: T.anything).void }
-      attr_writer :credit_details
+      attr_accessor :credit_details
 
       # Breakdown of debits
       sig { returns(T.nilable(T.anything)) }
-      attr_reader :debit_details
-
-      sig { params(debit_details: T.anything).void }
-      attr_writer :debit_details
+      attr_accessor :debit_details
 
       # Breakdown of payments
       sig { returns(T.nilable(T.anything)) }
-      attr_reader :payment_details
-
-      sig { params(payment_details: T.anything).void }
-      attr_writer :payment_details
+      attr_accessor :payment_details
 
       sig do
         params(
@@ -72,9 +63,9 @@ module Lithic
           interest: Integer,
           payments: Integer,
           purchases: Integer,
-          credit_details: T.anything,
-          debit_details: T.anything,
-          payment_details: T.anything
+          credit_details: T.nilable(T.anything),
+          debit_details: T.nilable(T.anything),
+          payment_details: T.nilable(T.anything)
         ).returns(T.attached_class)
       end
       def self.new(
@@ -115,9 +106,9 @@ module Lithic
             interest: Integer,
             payments: Integer,
             purchases: Integer,
-            credit_details: T.anything,
-            debit_details: T.anything,
-            payment_details: T.anything
+            credit_details: T.nilable(T.anything),
+            debit_details: T.nilable(T.anything),
+            payment_details: T.nilable(T.anything)
           }
         )
       end

data/rbi/lithic/models/tokenization_decline_reason.rbi

@@ -60,6 +60,8 @@ module Lithic
           :DIGITAL_CARD_ART_REQUIRED,
           Lithic::TokenizationDeclineReason::TaggedSymbol
         )
+      INVALID_PAN =
+        T.let(:INVALID_PAN, Lithic::TokenizationDeclineReason::TaggedSymbol)
 
       sig do
         override.returns(

data/rbi/lithic/models/transaction.rbi

@@ -1551,7 +1551,7 @@ module Lithic
         sig do
           params(
             network_specific_data:
-              Lithic::Transaction::Event::NetworkSpecificData::OrHash
+              T.nilable(Lithic::Transaction::Event::NetworkSpecificData::OrHash)
           ).void
         end
         attr_writer :network_specific_data
@@ -1574,7 +1574,7 @@ module Lithic
             type: Lithic::Transaction::Event::Type::OrSymbol,
             account_type: Lithic::Transaction::Event::AccountType::OrSymbol,
             network_specific_data:
-              Lithic::Transaction::Event::NetworkSpecificData::OrHash
+              T.nilable(Lithic::Transaction::Event::NetworkSpecificData::OrHash)
           ).returns(T.attached_class)
         end
         def self.new(
@@ -1627,7 +1627,7 @@ module Lithic
               account_type:
                 Lithic::Transaction::Event::AccountType::TaggedSymbol,
               network_specific_data:
-                Lithic::Transaction::Event::NetworkSpecificData
+                T.nilable(Lithic::Transaction::Event::NetworkSpecificData)
             }
           )
         end

data/rbi/lithic/models/transaction_monitoring/case_activity_entry.rbi

@@ -0,0 +1,107 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseActivityEntry < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseActivityEntry,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Globally unique identifier for the activity entry
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Identifier of the actor that produced the activity entry
+        sig { returns(T.nilable(String)) }
+        attr_accessor :actor_token
+
+        # Date and time at which the activity entry was created
+        sig { returns(Time) }
+        attr_accessor :created
+
+        # The case field that changed, or the action that was taken, in an activity entry:
+        #
+        # - `STATUS` - The case status changed
+        # - `TITLE` - The case title changed
+        # - `ASSIGNED_TO` - The case assignee changed
+        # - `RESOLUTION_OUTCOME` - The resolution outcome was set or changed
+        # - `RESOLUTION_NOTES` - The resolution notes were set or changed
+        # - `TAGS` - The case tags changed
+        # - `PRIORITY` - The case priority changed
+        # - `COMMENT` - A comment was added or edited
+        # - `FILE` - A file was attached to the case
+        sig do
+          returns(Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol)
+        end
+        attr_accessor :entry_type
+
+        # New value of the changed field, when applicable
+        sig { returns(T.nilable(String)) }
+        attr_accessor :new_value
+
+        # Previous value of the changed field, when applicable
+        sig { returns(T.nilable(String)) }
+        attr_accessor :previous_value
+
+        # A single entry in a case's activity feed
+        sig do
+          params(
+            token: String,
+            actor_token: T.nilable(String),
+            created: Time,
+            entry_type:
+              Lithic::TransactionMonitoring::CaseActivityType::OrSymbol,
+            new_value: T.nilable(String),
+            previous_value: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Globally unique identifier for the activity entry
+          token:,
+          # Identifier of the actor that produced the activity entry
+          actor_token:,
+          # Date and time at which the activity entry was created
+          created:,
+          # The case field that changed, or the action that was taken, in an activity entry:
+          #
+          # - `STATUS` - The case status changed
+          # - `TITLE` - The case title changed
+          # - `ASSIGNED_TO` - The case assignee changed
+          # - `RESOLUTION_OUTCOME` - The resolution outcome was set or changed
+          # - `RESOLUTION_NOTES` - The resolution notes were set or changed
+          # - `TAGS` - The case tags changed
+          # - `PRIORITY` - The case priority changed
+          # - `COMMENT` - A comment was added or edited
+          # - `FILE` - A file was attached to the case
+          entry_type:,
+          # New value of the changed field, when applicable
+          new_value:,
+          # Previous value of the changed field, when applicable
+          previous_value:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              token: String,
+              actor_token: T.nilable(String),
+              created: Time,
+              entry_type:
+                Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol,
+              new_value: T.nilable(String),
+              previous_value: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_activity_type.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      # The case field that changed, or the action that was taken, in an activity entry:
+      #
+      # - `STATUS` - The case status changed
+      # - `TITLE` - The case title changed
+      # - `ASSIGNED_TO` - The case assignee changed
+      # - `RESOLUTION_OUTCOME` - The resolution outcome was set or changed
+      # - `RESOLUTION_NOTES` - The resolution notes were set or changed
+      # - `TAGS` - The case tags changed
+      # - `PRIORITY` - The case priority changed
+      # - `COMMENT` - A comment was added or edited
+      # - `FILE` - A file was attached to the case
+      module CaseActivityType
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::TransactionMonitoring::CaseActivityType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        STATUS =
+          T.let(
+            :STATUS,
+            Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+          )
+        TITLE =
+          T.let(
+            :TITLE,
+            Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+          )
+        ASSIGNED_TO =
+          T.let(
+            :ASSIGNED_TO,
+            Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+          )
+        RESOLUTION_OUTCOME =
+          T.let(
+            :RESOLUTION_OUTCOME,
+            Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+          )
+        RESOLUTION_NOTES =
+          T.let(
+            :RESOLUTION_NOTES,
+            Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+          )
+        TAGS =
+          T.let(
+            :TAGS,
+            Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+          )
+        PRIORITY =
+          T.let(
+            :PRIORITY,
+            Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+          )
+        COMMENT =
+          T.let(
+            :COMMENT,
+            Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+          )
+        FILE =
+          T.let(
+            :FILE,
+            Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::TransactionMonitoring::CaseActivityType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_card.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseCard < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseCard,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Token of the account the card belongs to
+        sig { returns(String) }
+        attr_accessor :account_token
+
+        # Token of the card
+        sig { returns(String) }
+        attr_accessor :card_token
+
+        # Number of the card's transactions associated with the case
+        sig { returns(Integer) }
+        attr_accessor :transaction_count
+
+        # Summary of a card's involvement in a case, aggregated across the case's
+        # transactions
+        sig do
+          params(
+            account_token: String,
+            card_token: String,
+            transaction_count: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Token of the account the card belongs to
+          account_token:,
+          # Token of the card
+          card_token:,
+          # Number of the card's transactions associated with the case
+          transaction_count:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              account_token: String,
+              card_token: String,
+              transaction_count: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_entity.rbi

@@ -0,0 +1,101 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseEntity < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseEntity,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Globally unique identifier for the associated entity
+        sig { returns(String) }
+        attr_accessor :entity_token
+
+        # The type of entity a case is associated with:
+        #
+        # - `CARD` - The case is associated with a card
+        # - `ACCOUNT` - The case is associated with an account
+        sig do
+          returns(
+            Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+          )
+        end
+        attr_accessor :entity_type
+
+        # The entity a case is associated with
+        sig do
+          params(
+            entity_token: String,
+            entity_type:
+              Lithic::TransactionMonitoring::CaseEntity::EntityType::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Globally unique identifier for the associated entity
+          entity_token:,
+          # The type of entity a case is associated with:
+          #
+          # - `CARD` - The case is associated with a card
+          # - `ACCOUNT` - The case is associated with an account
+          entity_type:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              entity_token: String,
+              entity_type:
+                Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The type of entity a case is associated with:
+        #
+        # - `CARD` - The case is associated with a card
+        # - `ACCOUNT` - The case is associated with an account
+        module EntityType
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::TransactionMonitoring::CaseEntity::EntityType
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          CARD =
+            T.let(
+              :CARD,
+              Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+            )
+          ACCOUNT =
+            T.let(
+              :ACCOUNT,
+              Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_list_activity_params.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseListActivityParams < Lithic::Internal::Type::BaseModel
+        extend Lithic::Internal::Type::RequestParameters::Converter
+        include Lithic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseListActivityParams,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :case_token
+
+        # A cursor representing an item's token before which a page of results should end.
+        # Used to retrieve the previous page of results before this item.
+        sig { returns(T.nilable(String)) }
+        attr_reader :ending_before
+
+        sig { params(ending_before: String).void }
+        attr_writer :ending_before
+
+        # Page size (for pagination).
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page_size
+
+        sig { params(page_size: Integer).void }
+        attr_writer :page_size
+
+        # A cursor representing an item's token after which a page of results should
+        # begin. Used to retrieve the next page of results after this item.
+        sig { returns(T.nilable(String)) }
+        attr_reader :starting_after
+
+        sig { params(starting_after: String).void }
+        attr_writer :starting_after
+
+        sig do
+          params(
+            case_token: String,
+            ending_before: String,
+            page_size: Integer,
+            starting_after: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          case_token:,
+          # A cursor representing an item's token before which a page of results should end.
+          # Used to retrieve the previous page of results before this item.
+          ending_before: nil,
+          # Page size (for pagination).
+          page_size: nil,
+          # A cursor representing an item's token after which a page of results should
+          # begin. Used to retrieve the next page of results after this item.
+          starting_after: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              case_token: String,
+              ending_before: String,
+              page_size: Integer,
+              starting_after: String,
+              request_options: Lithic::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end