lithic 0.1.0.pre.alpha.55 → 0.1.0

data/rbi/lithic/models/network_total.rbi

@@ -0,0 +1,226 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class NetworkTotal < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Lithic::NetworkTotal, Lithic::Internal::AnyHash) }
+
+      # Globally unique identifier.
+      sig { returns(String) }
+      attr_accessor :token
+
+      sig { returns(Lithic::NetworkTotal::Amounts) }
+      attr_reader :amounts
+
+      sig { params(amounts: Lithic::NetworkTotal::Amounts::OrHash).void }
+      attr_writer :amounts
+
+      # RFC 3339 timestamp for when the record was created. UTC time zone.
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # 3-character alphabetic ISO 4217 code.
+      sig { returns(String) }
+      attr_accessor :currency
+
+      # The institution that activity occurred on. For Mastercard: ICA (Interbank Card
+      # Association). For Maestro: institution ID. For Visa: lowest level SRE
+      # (Settlement Reporting Entity).
+      sig { returns(String) }
+      attr_accessor :institution_id
+
+      # Indicates that all settlement records related to this Network Total are
+      # available in the details endpoint.
+      sig { returns(T::Boolean) }
+      attr_accessor :is_complete
+
+      # Card network where the transaction took place. AMEX, VISA, MASTERCARD, MAESTRO,
+      # or INTERLINK.
+      sig { returns(Lithic::NetworkTotal::Network::TaggedSymbol) }
+      attr_accessor :network
+
+      # Date that the network total record applies to. YYYY-MM-DD format.
+      sig { returns(Date) }
+      attr_accessor :report_date
+
+      # The institution responsible for settlement. For Mastercard: same as
+      # `institution_id`. For Maestro: billing ICA. For Visa: Funds Transfer SRE
+      # (FTSRE).
+      sig { returns(String) }
+      attr_accessor :settlement_institution_id
+
+      # Settlement service.
+      sig { returns(String) }
+      attr_accessor :settlement_service
+
+      # RFC 3339 timestamp for when the record was last updated. UTC time zone.
+      sig { returns(Time) }
+      attr_accessor :updated
+
+      # The clearing cycle that the network total record applies to. Mastercard only.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :cycle
+
+      sig { params(cycle: Integer).void }
+      attr_writer :cycle
+
+      sig do
+        params(
+          token: String,
+          amounts: Lithic::NetworkTotal::Amounts::OrHash,
+          created: Time,
+          currency: String,
+          institution_id: String,
+          is_complete: T::Boolean,
+          network: Lithic::NetworkTotal::Network::OrSymbol,
+          report_date: Date,
+          settlement_institution_id: String,
+          settlement_service: String,
+          updated: Time,
+          cycle: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Globally unique identifier.
+        token:,
+        amounts:,
+        # RFC 3339 timestamp for when the record was created. UTC time zone.
+        created:,
+        # 3-character alphabetic ISO 4217 code.
+        currency:,
+        # The institution that activity occurred on. For Mastercard: ICA (Interbank Card
+        # Association). For Maestro: institution ID. For Visa: lowest level SRE
+        # (Settlement Reporting Entity).
+        institution_id:,
+        # Indicates that all settlement records related to this Network Total are
+        # available in the details endpoint.
+        is_complete:,
+        # Card network where the transaction took place. AMEX, VISA, MASTERCARD, MAESTRO,
+        # or INTERLINK.
+        network:,
+        # Date that the network total record applies to. YYYY-MM-DD format.
+        report_date:,
+        # The institution responsible for settlement. For Mastercard: same as
+        # `institution_id`. For Maestro: billing ICA. For Visa: Funds Transfer SRE
+        # (FTSRE).
+        settlement_institution_id:,
+        # Settlement service.
+        settlement_service:,
+        # RFC 3339 timestamp for when the record was last updated. UTC time zone.
+        updated:,
+        # The clearing cycle that the network total record applies to. Mastercard only.
+        cycle: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            token: String,
+            amounts: Lithic::NetworkTotal::Amounts,
+            created: Time,
+            currency: String,
+            institution_id: String,
+            is_complete: T::Boolean,
+            network: Lithic::NetworkTotal::Network::TaggedSymbol,
+            report_date: Date,
+            settlement_institution_id: String,
+            settlement_service: String,
+            updated: Time,
+            cycle: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Amounts < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Lithic::NetworkTotal::Amounts, Lithic::Internal::AnyHash)
+          end
+
+        # Total settlement amount excluding interchange, in currency's smallest unit.
+        sig { returns(Integer) }
+        attr_accessor :gross_settlement
+
+        # Interchange amount, in currency's smallest unit.
+        sig { returns(Integer) }
+        attr_accessor :interchange_fees
+
+        # `gross_settlement` net of `interchange_fees` and `visa_charges` (if applicable),
+        # in currency's smallest unit.
+        sig { returns(Integer) }
+        attr_accessor :net_settlement
+
+        # Charges specific to Visa/Interlink, in currency's smallest unit.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :visa_charges
+
+        sig { params(visa_charges: Integer).void }
+        attr_writer :visa_charges
+
+        sig do
+          params(
+            gross_settlement: Integer,
+            interchange_fees: Integer,
+            net_settlement: Integer,
+            visa_charges: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Total settlement amount excluding interchange, in currency's smallest unit.
+          gross_settlement:,
+          # Interchange amount, in currency's smallest unit.
+          interchange_fees:,
+          # `gross_settlement` net of `interchange_fees` and `visa_charges` (if applicable),
+          # in currency's smallest unit.
+          net_settlement:,
+          # Charges specific to Visa/Interlink, in currency's smallest unit.
+          visa_charges: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              gross_settlement: Integer,
+              interchange_fees: Integer,
+              net_settlement: Integer,
+              visa_charges: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      # Card network where the transaction took place. AMEX, VISA, MASTERCARD, MAESTRO,
+      # or INTERLINK.
+      module Network
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::NetworkTotal::Network) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AMEX = T.let(:AMEX, Lithic::NetworkTotal::Network::TaggedSymbol)
+        VISA = T.let(:VISA, Lithic::NetworkTotal::Network::TaggedSymbol)
+        MASTERCARD =
+          T.let(:MASTERCARD, Lithic::NetworkTotal::Network::TaggedSymbol)
+        MAESTRO = T.let(:MAESTRO, Lithic::NetworkTotal::Network::TaggedSymbol)
+        INTERLINK =
+          T.let(:INTERLINK, Lithic::NetworkTotal::Network::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::NetworkTotal::Network::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/non_pci_card.rbi

@@ -99,6 +99,11 @@ module Lithic
       sig { params(auth_rule_tokens: T::Array[String]).void }
       attr_writer :auth_rule_tokens
 
+      # Globally unique identifier for the bulk order associated with this card. Only
+      # applicable to physical cards that are part of a bulk shipment
+      sig { returns(T.nilable(String)) }
+      attr_accessor :bulk_order_token
+
       # 3-character alphabetic ISO 4217 code for the currency of the cardholder.
       sig { returns(T.nilable(String)) }
       attr_reader :cardholder_currency
@@ -220,6 +225,7 @@ module Lithic
           state: Lithic::NonPCICard::State::OrSymbol,
           type: Lithic::NonPCICard::Type::OrSymbol,
           auth_rule_tokens: T::Array[String],
+          bulk_order_token: T.nilable(String),
           cardholder_currency: String,
           comment: String,
           digital_card_art_token: String,
@@ -298,6 +304,9 @@ module Lithic
         # key will be removed from the schema in a future release. Use the `/auth_rules`
         # endpoints to fetch Auth Rule information instead.
         auth_rule_tokens: nil,
+        # Globally unique identifier for the bulk order associated with this card. Only
+        # applicable to physical cards that are part of a bulk shipment
+        bulk_order_token: nil,
         # 3-character alphabetic ISO 4217 code for the currency of the cardholder.
         cardholder_currency: nil,
         # Additional context or information related to the card.
@@ -368,6 +377,7 @@ module Lithic
             state: Lithic::NonPCICard::State::TaggedSymbol,
             type: Lithic::NonPCICard::Type::TaggedSymbol,
             auth_rule_tokens: T::Array[String],
+            bulk_order_token: T.nilable(String),
             cardholder_currency: String,
             comment: String,
             digital_card_art_token: String,

data/rbi/lithic/models/payment.rbi

@@ -50,13 +50,14 @@ module Lithic
       sig { returns(Integer) }
       attr_accessor :pending_amount
 
-      # Related account tokens for the transaction
-      sig { returns(Lithic::Payment::RelatedAccountTokens) }
+      # Account tokens related to a payment transaction
+      sig { returns(T.nilable(Lithic::Payment::RelatedAccountTokens)) }
       attr_reader :related_account_tokens
 
       sig do
         params(
-          related_account_tokens: Lithic::Payment::RelatedAccountTokens::OrHash
+          related_account_tokens:
+            T.nilable(Lithic::Payment::RelatedAccountTokens::OrHash)
         ).void
       end
       attr_writer :related_account_tokens
@@ -123,7 +124,8 @@ module Lithic
               Lithic::Payment::MethodAttributes::WireMethodAttributes::OrHash
             ),
           pending_amount: Integer,
-          related_account_tokens: Lithic::Payment::RelatedAccountTokens::OrHash,
+          related_account_tokens:
+            T.nilable(Lithic::Payment::RelatedAccountTokens::OrHash),
           result: Lithic::Payment::Result::OrSymbol,
           settled_amount: Integer,
           source: Lithic::Payment::Source::OrSymbol,
@@ -158,7 +160,7 @@ module Lithic
         method_attributes:,
         # Pending amount in cents
         pending_amount:,
-        # Related account tokens for the transaction
+        # Account tokens related to a payment transaction
         related_account_tokens:,
         # Transaction result
         result:,
@@ -198,7 +200,8 @@ module Lithic
             method_: Lithic::Payment::Method::TaggedSymbol,
             method_attributes: Lithic::Payment::MethodAttributes::Variants,
             pending_amount: Integer,
-            related_account_tokens: Lithic::Payment::RelatedAccountTokens,
+            related_account_tokens:
+              T.nilable(Lithic::Payment::RelatedAccountTokens),
             result: Lithic::Payment::Result::TaggedSymbol,
             settled_amount: Integer,
             source: Lithic::Payment::Source::TaggedSymbol,
@@ -236,6 +239,10 @@ module Lithic
           T.let(:EXTERNAL_ACH, Lithic::Payment::Category::TaggedSymbol)
         EXTERNAL_CHECK =
           T.let(:EXTERNAL_CHECK, Lithic::Payment::Category::TaggedSymbol)
+        EXTERNAL_FEDNOW =
+          T.let(:EXTERNAL_FEDNOW, Lithic::Payment::Category::TaggedSymbol)
+        EXTERNAL_RTP =
+          T.let(:EXTERNAL_RTP, Lithic::Payment::Category::TaggedSymbol)
         EXTERNAL_TRANSFER =
           T.let(:EXTERNAL_TRANSFER, Lithic::Payment::Category::TaggedSymbol)
         EXTERNAL_WIRE =
@@ -567,6 +574,11 @@ module Lithic
               :APPROVED,
               Lithic::Payment::Event::DetailedResult::TaggedSymbol
             )
+          DECLINED =
+            T.let(
+              :DECLINED,
+              Lithic::Payment::Event::DetailedResult::TaggedSymbol
+            )
           FUNDS_INSUFFICIENT =
             T.let(
               :FUNDS_INSUFFICIENT,
@@ -652,6 +664,10 @@ module Lithic
           end
           attr_accessor :sec_code
 
+          # Number of days the ACH transaction is on hold
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :ach_hold_period
+
           # Addenda information
           sig { returns(T.nilable(String)) }
           attr_accessor :addenda
@@ -683,6 +699,7 @@ module Lithic
             params(
               sec_code:
                 Lithic::Payment::MethodAttributes::ACHMethodAttributes::SecCode::OrSymbol,
+              ach_hold_period: T.nilable(Integer),
               addenda: T.nilable(String),
               company_id: T.nilable(String),
               receipt_routing_number: T.nilable(String),
@@ -694,6 +711,8 @@ module Lithic
           def self.new(
             # SEC code for ACH transaction
             sec_code:,
+            # Number of days the ACH transaction is on hold
+            ach_hold_period: nil,
             # Addenda information
             addenda: nil,
             # Company ID for the ACH transaction
@@ -714,6 +733,7 @@ module Lithic
               {
                 sec_code:
                   Lithic::Payment::MethodAttributes::ACHMethodAttributes::SecCode::TaggedSymbol,
+                ach_hold_period: T.nilable(Integer),
                 addenda: T.nilable(String),
                 company_id: T.nilable(String),
                 receipt_routing_number: T.nilable(String),
@@ -928,7 +948,7 @@ module Lithic
         sig { returns(T.nilable(String)) }
         attr_accessor :business_account_token
 
-        # Related account tokens for the transaction
+        # Account tokens related to a payment transaction
         sig do
           params(
             account_token: T.nilable(String),
@@ -1002,6 +1022,7 @@ module Lithic
         DECLINED = T.let(:DECLINED, Lithic::Payment::Status::TaggedSymbol)
         REVERSED = T.let(:REVERSED, Lithic::Payment::Status::TaggedSymbol)
         CANCELED = T.let(:CANCELED, Lithic::Payment::Status::TaggedSymbol)
+        RETURNED = T.let(:RETURNED, Lithic::Payment::Status::TaggedSymbol)
 
         sig do
           override.returns(T::Array[Lithic::Payment::Status::TaggedSymbol])

data/rbi/lithic/models/payment_create_params.rbi

@@ -150,6 +150,13 @@ module Lithic
         end
         attr_accessor :sec_code
 
+        # Number of days to hold the ACH payment
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :ach_hold_period
+
+        sig { params(ach_hold_period: Integer).void }
+        attr_writer :ach_hold_period
+
         sig { returns(T.nilable(String)) }
         attr_accessor :addenda
 
@@ -157,10 +164,16 @@ module Lithic
           params(
             sec_code:
               Lithic::PaymentCreateParams::MethodAttributes::SecCode::OrSymbol,
+            ach_hold_period: Integer,
             addenda: T.nilable(String)
           ).returns(T.attached_class)
         end
-        def self.new(sec_code:, addenda: nil)
+        def self.new(
+          sec_code:,
+          # Number of days to hold the ACH payment
+          ach_hold_period: nil,
+          addenda: nil
+        )
         end
 
         sig do
@@ -168,6 +181,7 @@ module Lithic
             {
               sec_code:
                 Lithic::PaymentCreateParams::MethodAttributes::SecCode::OrSymbol,
+              ach_hold_period: Integer,
               addenda: T.nilable(String)
             }
           )

data/rbi/lithic/models/payment_return_params.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class PaymentReturnParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::PaymentReturnParams, Lithic::Internal::AnyHash)
+        end
+
+      # Globally unique identifier for the financial account
+      sig { returns(String) }
+      attr_accessor :financial_account_token
+
+      # ACH return reason code indicating the reason for returning the payment.
+      # Supported codes include R01-R53 and R80-R85. For a complete list of return codes
+      # and their meanings, see
+      # [ACH Return Reasons](https://docs.lithic.com/docs/ach-overview#ach-return-reasons)
+      sig { returns(String) }
+      attr_accessor :return_reason_code
+
+      # Optional additional information about the return. Limited to 44 characters
+      sig { returns(T.nilable(String)) }
+      attr_accessor :addenda
+
+      # Date of death in YYYY-MM-DD format. Required when using return codes **R14**
+      # (representative payee deceased) or **R15** (beneficiary or account holder
+      # deceased)
+      sig { returns(T.nilable(Date)) }
+      attr_accessor :date_of_death
+
+      # Optional memo for the return. Limited to 10 characters
+      sig { returns(T.nilable(String)) }
+      attr_accessor :memo
+
+      sig do
+        params(
+          financial_account_token: String,
+          return_reason_code: String,
+          addenda: T.nilable(String),
+          date_of_death: T.nilable(Date),
+          memo: T.nilable(String),
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Globally unique identifier for the financial account
+        financial_account_token:,
+        # ACH return reason code indicating the reason for returning the payment.
+        # Supported codes include R01-R53 and R80-R85. For a complete list of return codes
+        # and their meanings, see
+        # [ACH Return Reasons](https://docs.lithic.com/docs/ach-overview#ach-return-reasons)
+        return_reason_code:,
+        # Optional additional information about the return. Limited to 44 characters
+        addenda: nil,
+        # Date of death in YYYY-MM-DD format. Required when using return codes **R14**
+        # (representative payee deceased) or **R15** (beneficiary or account holder
+        # deceased)
+        date_of_death: nil,
+        # Optional memo for the return. Limited to 10 characters
+        memo: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            financial_account_token: String,
+            return_reason_code: String,
+            addenda: T.nilable(String),
+            date_of_death: T.nilable(Date),
+            memo: T.nilable(String),
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/statement_totals.rbi

@@ -0,0 +1,128 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class StatementTotals < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::StatementTotals, Lithic::Internal::AnyHash)
+        end
+
+      # Opening balance transferred from previous account in cents
+      sig { returns(Integer) }
+      attr_accessor :balance_transfers
+
+      # ATM and cashback transactions in cents
+      sig { returns(Integer) }
+      attr_accessor :cash_advances
+
+      # Volume of credit management operation transactions less any balance transfers in
+      # cents
+      sig { returns(Integer) }
+      attr_accessor :credits
+
+      # Volume of debit management operation transactions less any interest in cents
+      sig { returns(Integer) }
+      attr_accessor :debits
+
+      # Volume of debit management operation transactions less any interest in cents
+      sig { returns(Integer) }
+      attr_accessor :fees
+
+      # Interest accrued in cents
+      sig { returns(Integer) }
+      attr_accessor :interest
+
+      # Any funds transfers which affective the balance in cents
+      sig { returns(Integer) }
+      attr_accessor :payments
+
+      # Net card transaction volume less any cash advances in cents
+      sig { returns(Integer) }
+      attr_accessor :purchases
+
+      # Breakdown of credits
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :credit_details
+
+      sig { params(credit_details: T.anything).void }
+      attr_writer :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
+
+      # Breakdown of payments
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :payment_details
+
+      sig { params(payment_details: T.anything).void }
+      attr_writer :payment_details
+
+      sig do
+        params(
+          balance_transfers: Integer,
+          cash_advances: Integer,
+          credits: Integer,
+          debits: Integer,
+          fees: Integer,
+          interest: Integer,
+          payments: Integer,
+          purchases: Integer,
+          credit_details: T.anything,
+          debit_details: T.anything,
+          payment_details: T.anything
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Opening balance transferred from previous account in cents
+        balance_transfers:,
+        # ATM and cashback transactions in cents
+        cash_advances:,
+        # Volume of credit management operation transactions less any balance transfers in
+        # cents
+        credits:,
+        # Volume of debit management operation transactions less any interest in cents
+        debits:,
+        # Volume of debit management operation transactions less any interest in cents
+        fees:,
+        # Interest accrued in cents
+        interest:,
+        # Any funds transfers which affective the balance in cents
+        payments:,
+        # Net card transaction volume less any cash advances in cents
+        purchases:,
+        # Breakdown of credits
+        credit_details: nil,
+        # Breakdown of debits
+        debit_details: nil,
+        # Breakdown of payments
+        payment_details: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            balance_transfers: Integer,
+            cash_advances: Integer,
+            credits: Integer,
+            debits: Integer,
+            fees: Integer,
+            interest: Integer,
+            payments: Integer,
+            purchases: Integer,
+            credit_details: T.anything,
+            debit_details: T.anything,
+            payment_details: T.anything
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end