lithic 0.2.0 → 0.3.0

data/rbi/lithic/models/transfer_limits_response.rbi

@@ -0,0 +1,604 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TransferLimitsResponse < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::TransferLimitsResponse, Lithic::Internal::AnyHash)
+        end
+
+      # List of transfer limits
+      sig { returns(T::Array[Lithic::TransferLimitsResponse::Data]) }
+      attr_accessor :data
+
+      # Whether there are more transfer limits
+      sig { returns(T::Boolean) }
+      attr_accessor :has_more
+
+      sig do
+        params(
+          data: T::Array[Lithic::TransferLimitsResponse::Data::OrHash],
+          has_more: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # List of transfer limits
+        data:,
+        # Whether there are more transfer limits
+        has_more:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T::Array[Lithic::TransferLimitsResponse::Data],
+            has_more: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransferLimitsResponse::Data,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Company ID
+        sig { returns(String) }
+        attr_accessor :company_id
+
+        # Daily limits with progress
+        sig { returns(Lithic::TransferLimitsResponse::Data::DailyLimit) }
+        attr_reader :daily_limit
+
+        sig do
+          params(
+            daily_limit:
+              Lithic::TransferLimitsResponse::Data::DailyLimit::OrHash
+          ).void
+        end
+        attr_writer :daily_limit
+
+        # The date for the limit view (ISO format)
+        sig { returns(Date) }
+        attr_accessor :date
+
+        # Whether the company is a FBO; based on the company ID prefix
+        sig { returns(T::Boolean) }
+        attr_accessor :is_fbo
+
+        # Monthly limits with progress
+        sig { returns(Lithic::TransferLimitsResponse::Data::MonthlyLimit) }
+        attr_reader :monthly_limit
+
+        sig do
+          params(
+            monthly_limit:
+              Lithic::TransferLimitsResponse::Data::MonthlyLimit::OrHash
+          ).void
+        end
+        attr_writer :monthly_limit
+
+        # Program transaction limits
+        sig do
+          returns(
+            Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction
+          )
+        end
+        attr_reader :program_limit_per_transaction
+
+        sig do
+          params(
+            program_limit_per_transaction:
+              Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::OrHash
+          ).void
+        end
+        attr_writer :program_limit_per_transaction
+
+        sig do
+          params(
+            company_id: String,
+            daily_limit:
+              Lithic::TransferLimitsResponse::Data::DailyLimit::OrHash,
+            date: Date,
+            is_fbo: T::Boolean,
+            monthly_limit:
+              Lithic::TransferLimitsResponse::Data::MonthlyLimit::OrHash,
+            program_limit_per_transaction:
+              Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Company ID
+          company_id:,
+          # Daily limits with progress
+          daily_limit:,
+          # The date for the limit view (ISO format)
+          date:,
+          # Whether the company is a FBO; based on the company ID prefix
+          is_fbo:,
+          # Monthly limits with progress
+          monthly_limit:,
+          # Program transaction limits
+          program_limit_per_transaction:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              company_id: String,
+              daily_limit: Lithic::TransferLimitsResponse::Data::DailyLimit,
+              date: Date,
+              is_fbo: T::Boolean,
+              monthly_limit: Lithic::TransferLimitsResponse::Data::MonthlyLimit,
+              program_limit_per_transaction:
+                Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class DailyLimit < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::TransferLimitsResponse::Data::DailyLimit,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Credit limits
+          sig do
+            returns(Lithic::TransferLimitsResponse::Data::DailyLimit::Credit)
+          end
+          attr_reader :credit
+
+          sig do
+            params(
+              credit:
+                Lithic::TransferLimitsResponse::Data::DailyLimit::Credit::OrHash
+            ).void
+          end
+          attr_writer :credit
+
+          # Debit limits
+          sig do
+            returns(Lithic::TransferLimitsResponse::Data::DailyLimit::Debit)
+          end
+          attr_reader :debit
+
+          sig do
+            params(
+              debit:
+                Lithic::TransferLimitsResponse::Data::DailyLimit::Debit::OrHash
+            ).void
+          end
+          attr_writer :debit
+
+          # Daily limits with progress
+          sig do
+            params(
+              credit:
+                Lithic::TransferLimitsResponse::Data::DailyLimit::Credit::OrHash,
+              debit:
+                Lithic::TransferLimitsResponse::Data::DailyLimit::Debit::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Credit limits
+            credit:,
+            # Debit limits
+            debit:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                credit:
+                  Lithic::TransferLimitsResponse::Data::DailyLimit::Credit,
+                debit: Lithic::TransferLimitsResponse::Data::DailyLimit::Debit
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Credit < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::TransferLimitsResponse::Data::DailyLimit::Credit,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # The limit amount
+            sig { returns(Integer) }
+            attr_accessor :limit
+
+            # Amount originated towards limit
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :amount_originated
+
+            sig { params(amount_originated: Integer).void }
+            attr_writer :amount_originated
+
+            # Credit limits
+            sig do
+              params(limit: Integer, amount_originated: Integer).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # The limit amount
+              limit:,
+              # Amount originated towards limit
+              amount_originated: nil
+            )
+            end
+
+            sig do
+              override.returns({ limit: Integer, amount_originated: Integer })
+            end
+            def to_hash
+            end
+          end
+
+          class Debit < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::TransferLimitsResponse::Data::DailyLimit::Debit,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # The limit amount
+            sig { returns(Integer) }
+            attr_accessor :limit
+
+            # Amount originated towards limit
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :amount_originated
+
+            sig { params(amount_originated: Integer).void }
+            attr_writer :amount_originated
+
+            # Debit limits
+            sig do
+              params(limit: Integer, amount_originated: Integer).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # The limit amount
+              limit:,
+              # Amount originated towards limit
+              amount_originated: nil
+            )
+            end
+
+            sig do
+              override.returns({ limit: Integer, amount_originated: Integer })
+            end
+            def to_hash
+            end
+          end
+        end
+
+        class MonthlyLimit < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::TransferLimitsResponse::Data::MonthlyLimit,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Credit limits
+          sig do
+            returns(Lithic::TransferLimitsResponse::Data::MonthlyLimit::Credit)
+          end
+          attr_reader :credit
+
+          sig do
+            params(
+              credit:
+                Lithic::TransferLimitsResponse::Data::MonthlyLimit::Credit::OrHash
+            ).void
+          end
+          attr_writer :credit
+
+          # Debit limits
+          sig do
+            returns(Lithic::TransferLimitsResponse::Data::MonthlyLimit::Debit)
+          end
+          attr_reader :debit
+
+          sig do
+            params(
+              debit:
+                Lithic::TransferLimitsResponse::Data::MonthlyLimit::Debit::OrHash
+            ).void
+          end
+          attr_writer :debit
+
+          # Monthly limits with progress
+          sig do
+            params(
+              credit:
+                Lithic::TransferLimitsResponse::Data::MonthlyLimit::Credit::OrHash,
+              debit:
+                Lithic::TransferLimitsResponse::Data::MonthlyLimit::Debit::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Credit limits
+            credit:,
+            # Debit limits
+            debit:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                credit:
+                  Lithic::TransferLimitsResponse::Data::MonthlyLimit::Credit,
+                debit: Lithic::TransferLimitsResponse::Data::MonthlyLimit::Debit
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Credit < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::TransferLimitsResponse::Data::MonthlyLimit::Credit,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # The limit amount
+            sig { returns(Integer) }
+            attr_accessor :limit
+
+            # Amount originated towards limit
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :amount_originated
+
+            sig { params(amount_originated: Integer).void }
+            attr_writer :amount_originated
+
+            # Credit limits
+            sig do
+              params(limit: Integer, amount_originated: Integer).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # The limit amount
+              limit:,
+              # Amount originated towards limit
+              amount_originated: nil
+            )
+            end
+
+            sig do
+              override.returns({ limit: Integer, amount_originated: Integer })
+            end
+            def to_hash
+            end
+          end
+
+          class Debit < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::TransferLimitsResponse::Data::MonthlyLimit::Debit,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # The limit amount
+            sig { returns(Integer) }
+            attr_accessor :limit
+
+            # Amount originated towards limit
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :amount_originated
+
+            sig { params(amount_originated: Integer).void }
+            attr_writer :amount_originated
+
+            # Debit limits
+            sig do
+              params(limit: Integer, amount_originated: Integer).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # The limit amount
+              limit:,
+              # Amount originated towards limit
+              amount_originated: nil
+            )
+            end
+
+            sig do
+              override.returns({ limit: Integer, amount_originated: Integer })
+            end
+            def to_hash
+            end
+          end
+        end
+
+        class ProgramLimitPerTransaction < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Credit limits
+          sig do
+            returns(
+              Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Credit
+            )
+          end
+          attr_reader :credit
+
+          sig do
+            params(
+              credit:
+                Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Credit::OrHash
+            ).void
+          end
+          attr_writer :credit
+
+          # Debit limits
+          sig do
+            returns(
+              Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Debit
+            )
+          end
+          attr_reader :debit
+
+          sig do
+            params(
+              debit:
+                Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Debit::OrHash
+            ).void
+          end
+          attr_writer :debit
+
+          # Program transaction limits
+          sig do
+            params(
+              credit:
+                Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Credit::OrHash,
+              debit:
+                Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Debit::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Credit limits
+            credit:,
+            # Debit limits
+            debit:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                credit:
+                  Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Credit,
+                debit:
+                  Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Debit
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Credit < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Credit,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # The limit amount
+            sig { returns(Integer) }
+            attr_accessor :limit
+
+            # Amount originated towards limit
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :amount_originated
+
+            sig { params(amount_originated: Integer).void }
+            attr_writer :amount_originated
+
+            # Credit limits
+            sig do
+              params(limit: Integer, amount_originated: Integer).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # The limit amount
+              limit:,
+              # Amount originated towards limit
+              amount_originated: nil
+            )
+            end
+
+            sig do
+              override.returns({ limit: Integer, amount_originated: Integer })
+            end
+            def to_hash
+            end
+          end
+
+          class Debit < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::TransferLimitsResponse::Data::ProgramLimitPerTransaction::Debit,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # The limit amount
+            sig { returns(Integer) }
+            attr_accessor :limit
+
+            # Amount originated towards limit
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :amount_originated
+
+            sig { params(amount_originated: Integer).void }
+            attr_writer :amount_originated
+
+            # Debit limits
+            sig do
+              params(limit: Integer, amount_originated: Integer).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # The limit amount
+              limit:,
+              # Amount originated towards limit
+              amount_originated: nil
+            )
+            end
+
+            sig do
+              override.returns({ limit: Integer, amount_originated: Integer })
+            end
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models.rbi

@@ -62,14 +62,8 @@ module Lithic
 
   AddressUpdate = Lithic::Models::AddressUpdate
 
-  AggregateBalance = Lithic::Models::AggregateBalance
-
-  AggregateBalanceListParams = Lithic::Models::AggregateBalanceListParams
-
   APIStatus = Lithic::Models::APIStatus
 
-  AsaRequestWebhookEvent = Lithic::Models::AsaRequestWebhookEvent
-
   AuthRules = Lithic::Models::AuthRules
 
   AuthRulesBacktestReportCreatedWebhookEvent =
@@ -97,6 +91,8 @@ module Lithic
 
   BookTransferRetrieveParams = Lithic::Models::BookTransferRetrieveParams
 
+  BookTransferRetryParams = Lithic::Models::BookTransferRetryParams
+
   BookTransferReverseParams = Lithic::Models::BookTransferReverseParams
 
   BookTransferTransactionCreatedWebhookEvent =
@@ -107,6 +103,9 @@ module Lithic
 
   Card = Lithic::Models::Card
 
+  CardAuthorizationApprovalRequestWebhookEvent =
+    Lithic::Models::CardAuthorizationApprovalRequestWebhookEvent
+
   CardBulkOrder = Lithic::Models::CardBulkOrder
 
   CardBulkOrderCreateParams = Lithic::Models::CardBulkOrderCreateParams
@@ -492,6 +491,9 @@ module Lithic
 
   ThreeDSAuthentication = Lithic::Models::ThreeDSAuthentication
 
+  ThreeDSAuthenticationApprovalRequestWebhookEvent =
+    Lithic::Models::ThreeDSAuthenticationApprovalRequestWebhookEvent
+
   ThreeDSAuthenticationChallengeWebhookEvent =
     Lithic::Models::ThreeDSAuthenticationChallengeWebhookEvent
 
@@ -592,6 +594,10 @@ module Lithic
 
   TransferCreateParams = Lithic::Models::TransferCreateParams
 
+  TransferLimitListParams = Lithic::Models::TransferLimitListParams
+
+  TransferLimitsResponse = Lithic::Models::TransferLimitsResponse
+
   VerificationMethod = Lithic::Models::VerificationMethod
 
   WalletDecisioningInfo = Lithic::Models::WalletDecisioningInfo

data/rbi/lithic/resources/book_transfers.rbi

@@ -110,6 +110,24 @@ module Lithic
       )
       end
 
+      # Retry a book transfer that has been declined
+      sig do
+        params(
+          book_transfer_token: String,
+          retry_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::BookTransferResponse)
+      end
+      def retry_(
+        # Token of the book transfer to retry
+        book_transfer_token,
+        # Customer-provided token that will serve as an idempotency token. This token will
+        # become the transaction token.
+        retry_token:,
+        request_options: {}
+      )
+      end
+
       # Reverse a book transfer
       sig do
         params(

data/rbi/lithic/resources/cards.rbi

@@ -3,9 +3,6 @@
 module Lithic
   module Resources
     class Cards
-      sig { returns(Lithic::Resources::Cards::AggregateBalances) }
-      attr_reader :aggregate_balances
-
       sig { returns(Lithic::Resources::Cards::Balances) }
       attr_reader :balances
 
@@ -611,7 +608,7 @@ module Lithic
       end
 
       # Allow your cardholders to directly add payment cards to the device's digital
-      # wallet from a browser on the web. Currently only suported for Apple Pay.
+      # wallet from a browser on the web.
       #
       # This requires some additional setup and configuration. Please
       # [Contact Us](https://lithic.com/contact) or your Customer Success representative

data/rbi/lithic/resources/external_payments.rbi

@@ -26,6 +26,8 @@ module Lithic
         effective_date:,
         financial_account_token:,
         payment_type:,
+        # Customer-provided token that will serve as an idempotency token. This token will
+        # become the transaction token.
         token: nil,
         memo: nil,
         progress_to: nil,