lithic 0.1.0.pre.alpha.40 → 0.1.0.pre.alpha.42

data/rbi/lithic/models/management_operation_transaction.rbi

@@ -11,66 +11,81 @@ module Lithic
           )
         end
 
+      # Unique identifier for the transaction
       sig { returns(String) }
       attr_accessor :token
 
+      # ISO 8601 timestamp of when the transaction was created
+      sig { returns(Time) }
+      attr_accessor :created
+
       sig do
-        returns(Lithic::ManagementOperationTransaction::Category::TaggedSymbol)
+        returns(Lithic::ManagementOperationTransaction::Family::TaggedSymbol)
       end
-      attr_accessor :category
+      attr_accessor :family
 
-      sig { returns(Time) }
-      attr_accessor :created
+      # The status of the transaction
+      sig do
+        returns(Lithic::ManagementOperationTransaction::Status::TaggedSymbol)
+      end
+      attr_accessor :status
 
-      sig { returns(String) }
-      attr_accessor :currency
+      # ISO 8601 timestamp of when the transaction was last updated
+      sig { returns(Time) }
+      attr_accessor :updated
 
       sig do
-        returns(Lithic::ManagementOperationTransaction::Direction::TaggedSymbol)
+        returns(
+          T.nilable(
+            Lithic::ManagementOperationTransaction::Category::TaggedSymbol
+          )
+        )
       end
-      attr_accessor :direction
+      attr_reader :category
 
-      sig { returns(T::Array[Lithic::ManagementOperationTransaction::Event]) }
-      attr_accessor :events
+      sig do
+        params(
+          category: Lithic::ManagementOperationTransaction::Category::OrSymbol
+        ).void
+      end
+      attr_writer :category
 
-      sig { returns(String) }
-      attr_accessor :financial_account_token
+      sig { returns(T.nilable(String)) }
+      attr_reader :currency
 
-      sig { returns(Integer) }
-      attr_accessor :pending_amount
+      sig { params(currency: String).void }
+      attr_writer :currency
 
       sig do
-        returns(Lithic::ManagementOperationTransaction::Result::TaggedSymbol)
+        returns(
+          T.nilable(
+            Lithic::ManagementOperationTransaction::Direction::TaggedSymbol
+          )
+        )
       end
-      attr_accessor :result
-
-      sig { returns(Integer) }
-      attr_accessor :settled_amount
+      attr_reader :direction
 
       sig do
-        returns(Lithic::ManagementOperationTransaction::Status::TaggedSymbol)
+        params(
+          direction: Lithic::ManagementOperationTransaction::Direction::OrSymbol
+        ).void
       end
-      attr_accessor :status
+      attr_writer :direction
 
       sig do
         returns(
-          T.nilable(Lithic::ManagementOperationTransaction::TransactionSeries)
+          T.nilable(T::Array[Lithic::ManagementOperationTransaction::Event])
         )
       end
-      attr_reader :transaction_series
+      attr_reader :events
 
       sig do
         params(
-          transaction_series:
-            T.nilable(
-              Lithic::ManagementOperationTransaction::TransactionSeries::OrHash
-            )
+          events:
+            T::Array[Lithic::ManagementOperationTransaction::Event::OrHash]
         ).void
       end
-      attr_writer :transaction_series
-
-      sig { returns(Time) }
-      attr_accessor :updated
+      attr_writer :events
 
       # External resource associated with the management operation
       sig { returns(T.nilable(Lithic::ExternalResource)) }
@@ -83,6 +98,57 @@ module Lithic
       end
       attr_writer :external_resource
 
+      sig { returns(T.nilable(String)) }
+      attr_reader :financial_account_token
+
+      sig { params(financial_account_token: String).void }
+      attr_writer :financial_account_token
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :pending_amount
+
+      sig { params(pending_amount: Integer).void }
+      attr_writer :pending_amount
+
+      sig do
+        returns(
+          T.nilable(
+            Lithic::ManagementOperationTransaction::Result::TaggedSymbol
+          )
+        )
+      end
+      attr_reader :result
+
+      sig do
+        params(
+          result: Lithic::ManagementOperationTransaction::Result::OrSymbol
+        ).void
+      end
+      attr_writer :result
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :settled_amount
+
+      sig { params(settled_amount: Integer).void }
+      attr_writer :settled_amount
+
+      sig do
+        returns(
+          T.nilable(Lithic::ManagementOperationTransaction::TransactionSeries)
+        )
+      end
+      attr_reader :transaction_series
+
+      sig do
+        params(
+          transaction_series:
+            T.nilable(
+              Lithic::ManagementOperationTransaction::TransactionSeries::OrHash
+            )
+        ).void
+      end
+      attr_writer :transaction_series
+
       sig { returns(T.nilable(String)) }
       attr_reader :user_defined_id
 
@@ -92,43 +158,49 @@ module Lithic
       sig do
         params(
           token: String,
-          category: Lithic::ManagementOperationTransaction::Category::OrSymbol,
           created: Time,
+          family: Lithic::ManagementOperationTransaction::Family::OrSymbol,
+          status: Lithic::ManagementOperationTransaction::Status::OrSymbol,
+          updated: Time,
+          category: Lithic::ManagementOperationTransaction::Category::OrSymbol,
           currency: String,
           direction:
             Lithic::ManagementOperationTransaction::Direction::OrSymbol,
           events:
             T::Array[Lithic::ManagementOperationTransaction::Event::OrHash],
+          external_resource: T.nilable(Lithic::ExternalResource::OrHash),
           financial_account_token: String,
           pending_amount: Integer,
           result: Lithic::ManagementOperationTransaction::Result::OrSymbol,
           settled_amount: Integer,
-          status: Lithic::ManagementOperationTransaction::Status::OrSymbol,
           transaction_series:
             T.nilable(
               Lithic::ManagementOperationTransaction::TransactionSeries::OrHash
             ),
-          updated: Time,
-          external_resource: T.nilable(Lithic::ExternalResource::OrHash),
           user_defined_id: String
         ).returns(T.attached_class)
       end
       def self.new(
+        # Unique identifier for the transaction
         token:,
-        category:,
+        # ISO 8601 timestamp of when the transaction was created
         created:,
-        currency:,
-        direction:,
-        events:,
-        financial_account_token:,
-        pending_amount:,
-        result:,
-        settled_amount:,
+        family:,
+        # The status of the transaction
         status:,
-        transaction_series:,
+        # ISO 8601 timestamp of when the transaction was last updated
         updated:,
+        category: nil,
+        currency: nil,
+        direction: nil,
+        events: nil,
         # External resource associated with the management operation
         external_resource: nil,
+        financial_account_token: nil,
+        pending_amount: nil,
+        result: nil,
+        settled_amount: nil,
+        transaction_series: nil,
         user_defined_id: nil
       )
       end
@@ -137,26 +209,28 @@ module Lithic
         override.returns(
           {
             token: String,
+            created: Time,
+            family:
+              Lithic::ManagementOperationTransaction::Family::TaggedSymbol,
+            status:
+              Lithic::ManagementOperationTransaction::Status::TaggedSymbol,
+            updated: Time,
             category:
               Lithic::ManagementOperationTransaction::Category::TaggedSymbol,
-            created: Time,
             currency: String,
             direction:
               Lithic::ManagementOperationTransaction::Direction::TaggedSymbol,
             events: T::Array[Lithic::ManagementOperationTransaction::Event],
+            external_resource: T.nilable(Lithic::ExternalResource),
             financial_account_token: String,
             pending_amount: Integer,
             result:
               Lithic::ManagementOperationTransaction::Result::TaggedSymbol,
             settled_amount: Integer,
-            status:
-              Lithic::ManagementOperationTransaction::Status::TaggedSymbol,
             transaction_series:
               T.nilable(
                 Lithic::ManagementOperationTransaction::TransactionSeries
               ),
-            updated: Time,
-            external_resource: T.nilable(Lithic::ExternalResource),
             user_defined_id: String
           }
         )
@@ -164,6 +238,104 @@ module Lithic
       def to_hash
       end
 
+      module Family
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::ManagementOperationTransaction::Family)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CARD =
+          T.let(
+            :CARD,
+            Lithic::ManagementOperationTransaction::Family::TaggedSymbol
+          )
+        PAYMENT =
+          T.let(
+            :PAYMENT,
+            Lithic::ManagementOperationTransaction::Family::TaggedSymbol
+          )
+        TRANSFER =
+          T.let(
+            :TRANSFER,
+            Lithic::ManagementOperationTransaction::Family::TaggedSymbol
+          )
+        INTERNAL =
+          T.let(
+            :INTERNAL,
+            Lithic::ManagementOperationTransaction::Family::TaggedSymbol
+          )
+        EXTERNAL_PAYMENT =
+          T.let(
+            :EXTERNAL_PAYMENT,
+            Lithic::ManagementOperationTransaction::Family::TaggedSymbol
+          )
+        MANAGEMENT_OPERATION =
+          T.let(
+            :MANAGEMENT_OPERATION,
+            Lithic::ManagementOperationTransaction::Family::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::ManagementOperationTransaction::Family::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The status of the transaction
+      module Status
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::ManagementOperationTransaction::Status)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING =
+          T.let(
+            :PENDING,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
+        SETTLED =
+          T.let(
+            :SETTLED,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
+        DECLINED =
+          T.let(
+            :DECLINED,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
+        REVERSED =
+          T.let(
+            :REVERSED,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
+        CANCELED =
+          T.let(
+            :CANCELED,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
       module Category
         extend Lithic::Internal::Type::Enum
 
@@ -364,6 +536,11 @@ module Lithic
               :APPROVED,
               Lithic::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol
             )
+          INSUFFICIENT_FUNDS =
+            T.let(
+              :INSUFFICIENT_FUNDS,
+              Lithic::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol
+            )
 
           sig do
             override.returns(
@@ -558,52 +735,6 @@ module Lithic
         end
       end
 
-      module Status
-        extend Lithic::Internal::Type::Enum
-
-        TaggedSymbol =
-          T.type_alias do
-            T.all(Symbol, Lithic::ManagementOperationTransaction::Status)
-          end
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        PENDING =
-          T.let(
-            :PENDING,
-            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
-          )
-        SETTLED =
-          T.let(
-            :SETTLED,
-            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
-          )
-        DECLINED =
-          T.let(
-            :DECLINED,
-            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
-          )
-        REVERSED =
-          T.let(
-            :REVERSED,
-            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
-          )
-        CANCELED =
-          T.let(
-            :CANCELED,
-            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
-          )
-
-        sig do
-          override.returns(
-            T::Array[
-              Lithic::ManagementOperationTransaction::Status::TaggedSymbol
-            ]
-          )
-        end
-        def self.values
-        end
-      end
-
       class TransactionSeries < Lithic::Internal::Type::BaseModel
         OrHash =
           T.type_alias do

data/rbi/lithic/models/payment.rbi

@@ -58,6 +58,17 @@ module Lithic
       sig { returns(Integer) }
       attr_accessor :pending_amount
 
+      # Account tokens related to a payment transaction
+      sig { returns(Lithic::Payment::RelatedAccountTokens) }
+      attr_reader :related_account_tokens
+
+      sig do
+        params(
+          related_account_tokens: Lithic::Payment::RelatedAccountTokens::OrHash
+        ).void
+      end
+      attr_writer :related_account_tokens
+
       # APPROVED payments were successful while DECLINED payments were declined by
       # Lithic or returned.
       sig { returns(Lithic::Payment::Result::TaggedSymbol) }
@@ -95,6 +106,13 @@ module Lithic
       sig { params(expected_release_date: Date).void }
       attr_writer :expected_release_date
 
+      # Payment type indicating the specific ACH message or Fedwire transfer type
+      sig { returns(T.nilable(Lithic::Payment::Type::TaggedSymbol)) }
+      attr_reader :type
+
+      sig { params(type: Lithic::Payment::Type::OrSymbol).void }
+      attr_writer :type
+
       sig do
         params(
           token: String,
@@ -109,13 +127,15 @@ module Lithic
           method_: Lithic::Payment::Method::OrSymbol,
           method_attributes: Lithic::Payment::MethodAttributes::OrHash,
           pending_amount: Integer,
+          related_account_tokens: Lithic::Payment::RelatedAccountTokens::OrHash,
           result: Lithic::Payment::Result::OrSymbol,
           settled_amount: Integer,
           source: Lithic::Payment::Source::OrSymbol,
           status: Lithic::Payment::Status::OrSymbol,
           updated: Time,
           user_defined_id: T.nilable(String),
-          expected_release_date: Date
+          expected_release_date: Date,
+          type: Lithic::Payment::Type::OrSymbol
         ).returns(T.attached_class)
       end
       def self.new(
@@ -140,6 +160,8 @@ module Lithic
         # Pending amount of the payment in the currency's smallest unit (e.g., cents). The
         # value of this field will go to zero over time once the payment is settled.
         pending_amount:,
+        # Account tokens related to a payment transaction
+        related_account_tokens:,
         # APPROVED payments were successful while DECLINED payments were declined by
         # Lithic or returned.
         result:,
@@ -159,7 +181,9 @@ module Lithic
         updated:,
         user_defined_id:,
         # Date when the financial transaction expected to be released after settlement
-        expected_release_date: nil
+        expected_release_date: nil,
+        # Payment type indicating the specific ACH message or Fedwire transfer type
+        type: nil
       )
       end
 
@@ -178,13 +202,15 @@ module Lithic
             method_: Lithic::Payment::Method::TaggedSymbol,
             method_attributes: Lithic::Payment::MethodAttributes,
             pending_amount: Integer,
+            related_account_tokens: Lithic::Payment::RelatedAccountTokens,
             result: Lithic::Payment::Result::TaggedSymbol,
             settled_amount: Integer,
             source: Lithic::Payment::Source::TaggedSymbol,
             status: Lithic::Payment::Status::TaggedSymbol,
             updated: Time,
             user_defined_id: T.nilable(String),
-            expected_release_date: Date
+            expected_release_date: Date,
+            type: Lithic::Payment::Type::TaggedSymbol
           }
         )
       end
@@ -289,6 +315,7 @@ module Lithic
         end
         attr_writer :detailed_results
 
+        # Payment Event
         sig do
           params(
             token: String,
@@ -639,6 +666,50 @@ module Lithic
         end
       end
 
+      class RelatedAccountTokens < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::Payment::RelatedAccountTokens,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Globally unique identifier for the account
+        sig { returns(T.nilable(String)) }
+        attr_accessor :account_token
+
+        # Globally unique identifier for the business account
+        sig { returns(T.nilable(String)) }
+        attr_accessor :business_account_token
+
+        # Account tokens related to a payment transaction
+        sig do
+          params(
+            account_token: T.nilable(String),
+            business_account_token: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Globally unique identifier for the account
+          account_token:,
+          # Globally unique identifier for the business account
+          business_account_token:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              account_token: T.nilable(String),
+              business_account_token: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
       # APPROVED payments were successful while DECLINED payments were declined by
       # Lithic or returned.
       module Result
@@ -697,6 +768,35 @@ module Lithic
         def self.values
         end
       end
+
+      # Payment type indicating the specific ACH message or Fedwire transfer type
+      module Type
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Payment::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ORIGINATION_CREDIT =
+          T.let(:ORIGINATION_CREDIT, Lithic::Payment::Type::TaggedSymbol)
+        ORIGINATION_DEBIT =
+          T.let(:ORIGINATION_DEBIT, Lithic::Payment::Type::TaggedSymbol)
+        RECEIPT_CREDIT =
+          T.let(:RECEIPT_CREDIT, Lithic::Payment::Type::TaggedSymbol)
+        RECEIPT_DEBIT =
+          T.let(:RECEIPT_DEBIT, Lithic::Payment::Type::TaggedSymbol)
+        WIRE_INBOUND_PAYMENT =
+          T.let(:WIRE_INBOUND_PAYMENT, Lithic::Payment::Type::TaggedSymbol)
+        WIRE_INBOUND_ADMIN =
+          T.let(:WIRE_INBOUND_ADMIN, Lithic::Payment::Type::TaggedSymbol)
+        WIRE_OUTBOUND_PAYMENT =
+          T.let(:WIRE_OUTBOUND_PAYMENT, Lithic::Payment::Type::TaggedSymbol)
+        WIRE_OUTBOUND_ADMIN =
+          T.let(:WIRE_OUTBOUND_ADMIN, Lithic::Payment::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Payment::Type::TaggedSymbol]) }
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/lithic/models/reports/settlement_list_details_params.rbi

@@ -23,7 +23,7 @@ module Lithic
         sig { params(ending_before: String).void }
         attr_writer :ending_before
 
-        # Page size (for pagination).
+        # Number of records per page.
         sig { returns(T.nilable(Integer)) }
         attr_reader :page_size
 
@@ -50,7 +50,7 @@ module Lithic
           # 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).
+          # Number of records per page.
           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.

data/rbi/lithic/models/settlement_detail.rbi

@@ -286,6 +286,8 @@ module Lithic
           T.let(:CHARGEBACK, Lithic::SettlementDetail::Type::TaggedSymbol)
         CLEARING =
           T.let(:CLEARING, Lithic::SettlementDetail::Type::TaggedSymbol)
+        COLLABORATION =
+          T.let(:COLLABORATION, Lithic::SettlementDetail::Type::TaggedSymbol)
         FEE = T.let(:FEE, Lithic::SettlementDetail::Type::TaggedSymbol)
         FINANCIAL =
           T.let(:FINANCIAL, Lithic::SettlementDetail::Type::TaggedSymbol)