lithic 0.7.0 → 0.8.0

data/rbi/lithic/models/financial_account.rbi

@@ -344,6 +344,11 @@ module Lithic
             :PROGRAM_BANK_ACCOUNTS_PAYABLE,
             Lithic::FinancialAccount::Type::TaggedSymbol
           )
+        EARLY_DIRECT_DEPOSIT_FLOAT =
+          T.let(
+            :EARLY_DIRECT_DEPOSIT_FLOAT,
+            Lithic::FinancialAccount::Type::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/rbi/lithic/models/financial_account_list_params.rbi

@@ -98,6 +98,11 @@ module Lithic
             :SECURITY,
             Lithic::FinancialAccountListParams::Type::TaggedSymbol
           )
+        EARLY_DIRECT_DEPOSIT_FLOAT =
+          T.let(
+            :EARLY_DIRECT_DEPOSIT_FLOAT,
+            Lithic::FinancialAccountListParams::Type::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/rbi/lithic/models/financial_accounts/interest_tier_schedule.rbi

@@ -20,6 +20,13 @@ module Lithic
         sig { returns(Date) }
         attr_accessor :effective_date
 
+        # Custom rates per category for penalties
+        sig { returns(T.nilable(T.anything)) }
+        attr_reader :penalty_rates
+
+        sig { params(penalty_rates: T.anything).void }
+        attr_writer :penalty_rates
+
         # Name of a tier contained in the credit product. Mutually exclusive with
         # tier_rates
         sig { returns(T.nilable(String)) }
@@ -40,6 +47,7 @@ module Lithic
           params(
             credit_product_token: String,
             effective_date: Date,
+            penalty_rates: T.anything,
             tier_name: String,
             tier_rates: T.anything
           ).returns(T.attached_class)
@@ -49,6 +57,8 @@ module Lithic
           credit_product_token:,
           # Date the tier should be effective in YYYY-MM-DD format
           effective_date:,
+          # Custom rates per category for penalties
+          penalty_rates: nil,
           # Name of a tier contained in the credit product. Mutually exclusive with
           # tier_rates
           tier_name: nil,
@@ -62,6 +72,7 @@ module Lithic
             {
               credit_product_token: String,
               effective_date: Date,
+              penalty_rates: T.anything,
               tier_name: String,
               tier_rates: T.anything
             }

data/rbi/lithic/models/financial_accounts/interest_tier_schedule_update_params.rbi

@@ -21,6 +21,13 @@ module Lithic
         sig { returns(Date) }
         attr_accessor :effective_date
 
+        # Custom rates per category for penalties
+        sig { returns(T.nilable(T.anything)) }
+        attr_reader :penalty_rates
+
+        sig { params(penalty_rates: T.anything).void }
+        attr_writer :penalty_rates
+
         # Name of a tier contained in the credit product. Mutually exclusive with
         # tier_rates
         sig { returns(T.nilable(String)) }
@@ -40,6 +47,7 @@ module Lithic
           params(
             financial_account_token: String,
             effective_date: Date,
+            penalty_rates: T.anything,
             tier_name: String,
             tier_rates: T.anything,
             request_options: Lithic::RequestOptions::OrHash
@@ -48,6 +56,8 @@ module Lithic
         def self.new(
           financial_account_token:,
           effective_date:,
+          # Custom rates per category for penalties
+          penalty_rates: nil,
           # Name of a tier contained in the credit product. Mutually exclusive with
           # tier_rates
           tier_name: nil,
@@ -62,6 +72,7 @@ module Lithic
             {
               financial_account_token: String,
               effective_date: Date,
+              penalty_rates: T.anything,
               tier_name: String,
               tier_rates: T.anything,
               request_options: Lithic::RequestOptions

data/rbi/lithic/models/financial_accounts/statements/statement_line_items.rbi

@@ -70,6 +70,9 @@ module Lithic
             sig { returns(Integer) }
             attr_accessor :amount
 
+            # Note: Inbound wire transfers are coming soon (availability varies by partner
+            # bank). The WIRE category is a preview. To learn more, contact your customer
+            # success manager.
             sig do
               returns(
                 Lithic::FinancialAccounts::Statements::StatementLineItems::Data::Category::TaggedSymbol
@@ -122,6 +125,14 @@ module Lithic
             sig { params(descriptor: String).void }
             attr_writer :descriptor
 
+            # Subtype of the event that generated the line items
+            sig { returns(T.nilable(String)) }
+            attr_accessor :event_subtype
+
+            # Date of the loan tape that generated this line item
+            sig { returns(T.nilable(Date)) }
+            attr_accessor :loan_tape_date
+
             sig do
               params(
                 token: String,
@@ -137,7 +148,9 @@ module Lithic
                 financial_transaction_event_token: String,
                 financial_transaction_token: String,
                 card_token: String,
-                descriptor: String
+                descriptor: String,
+                event_subtype: T.nilable(String),
+                loan_tape_date: T.nilable(Date)
               ).returns(T.attached_class)
             end
             def self.new(
@@ -145,6 +158,9 @@ module Lithic
               token:,
               # Transaction amount in cents
               amount:,
+              # Note: Inbound wire transfers are coming soon (availability varies by partner
+              # bank). The WIRE category is a preview. To learn more, contact your customer
+              # success manager.
               category:,
               # Timestamp of when the line item was generated
               created:,
@@ -162,7 +178,11 @@ module Lithic
               financial_transaction_token:,
               # Globally unique identifier for a card
               card_token: nil,
-              descriptor: nil
+              descriptor: nil,
+              # Subtype of the event that generated the line items
+              event_subtype: nil,
+              # Date of the loan tape that generated this line item
+              loan_tape_date: nil
             )
             end
 
@@ -182,13 +202,18 @@ module Lithic
                   financial_transaction_event_token: String,
                   financial_transaction_token: String,
                   card_token: String,
-                  descriptor: String
+                  descriptor: String,
+                  event_subtype: T.nilable(String),
+                  loan_tape_date: T.nilable(Date)
                 }
               )
             end
             def to_hash
             end
 
+            # Note: Inbound wire transfers are coming soon (availability varies by partner
+            # bank). The WIRE category is a preview. To learn more, contact your customer
+            # success manager.
             module Category
               extend Lithic::Internal::Type::Enum
 
@@ -206,6 +231,11 @@ module Lithic
                   :ACH,
                   Lithic::FinancialAccounts::Statements::StatementLineItems::Data::Category::TaggedSymbol
                 )
+              WIRE =
+                T.let(
+                  :WIRE,
+                  Lithic::FinancialAccounts::Statements::StatementLineItems::Data::Category::TaggedSymbol
+                )
               BALANCE_OR_FUNDING =
                 T.let(
                   :BALANCE_OR_FUNDING,
@@ -296,6 +326,11 @@ module Lithic
                   :MANAGEMENT_DISBURSEMENT,
                   Lithic::FinancialAccounts::Statements::StatementLineItems::Data::Category::TaggedSymbol
                 )
+              HOLD =
+                T.let(
+                  :HOLD,
+                  Lithic::FinancialAccounts::Statements::StatementLineItems::Data::Category::TaggedSymbol
+                )
               PROGRAM_FUNDING =
                 T.let(
                   :PROGRAM_FUNDING,

data/rbi/lithic/models/hold.rbi

@@ -0,0 +1,183 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class Hold < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Lithic::Hold, Lithic::Internal::AnyHash) }
+
+      # 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
+
+      # Status of a hold transaction
+      sig { returns(Lithic::Hold::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      # ISO 8601 timestamp of when the transaction was last updated
+      sig { returns(Time) }
+      attr_accessor :updated
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :currency
+
+      sig { params(currency: String).void }
+      attr_writer :currency
+
+      sig { returns(T.nilable(T::Array[Lithic::HoldEvent])) }
+      attr_reader :events
+
+      sig { params(events: T::Array[Lithic::HoldEvent::OrHash]).void }
+      attr_writer :events
+
+      # When the hold will auto-expire if not resolved
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :expiration_datetime
+
+      # HOLD - Hold Transaction
+      sig { returns(T.nilable(Lithic::Hold::Family::TaggedSymbol)) }
+      attr_reader :family
+
+      sig { params(family: Lithic::Hold::Family::OrSymbol).void }
+      attr_writer :family
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :financial_account_token
+
+      sig { params(financial_account_token: String).void }
+      attr_writer :financial_account_token
+
+      # Current pending amount (0 when resolved)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :pending_amount
+
+      sig { params(pending_amount: Integer).void }
+      attr_writer :pending_amount
+
+      sig { returns(T.nilable(Lithic::Hold::Result::TaggedSymbol)) }
+      attr_reader :result
+
+      sig { params(result: Lithic::Hold::Result::OrSymbol).void }
+      attr_writer :result
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :user_defined_id
+
+      # A hold transaction representing reserved funds on a financial account. Holds
+      # move funds from available to pending balance in anticipation of future payments.
+      # They can be resolved via settlement (linked to payment), manual release, or
+      # expiration.
+      sig do
+        params(
+          token: String,
+          created: Time,
+          status: Lithic::Hold::Status::OrSymbol,
+          updated: Time,
+          currency: String,
+          events: T::Array[Lithic::HoldEvent::OrHash],
+          expiration_datetime: T.nilable(Time),
+          family: Lithic::Hold::Family::OrSymbol,
+          financial_account_token: String,
+          pending_amount: Integer,
+          result: Lithic::Hold::Result::OrSymbol,
+          user_defined_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the transaction
+        token:,
+        # ISO 8601 timestamp of when the transaction was created
+        created:,
+        # Status of a hold transaction
+        status:,
+        # ISO 8601 timestamp of when the transaction was last updated
+        updated:,
+        currency: nil,
+        events: nil,
+        # When the hold will auto-expire if not resolved
+        expiration_datetime: nil,
+        # HOLD - Hold Transaction
+        family: nil,
+        financial_account_token: nil,
+        # Current pending amount (0 when resolved)
+        pending_amount: nil,
+        result: nil,
+        user_defined_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            token: String,
+            created: Time,
+            status: Lithic::Hold::Status::TaggedSymbol,
+            updated: Time,
+            currency: String,
+            events: T::Array[Lithic::HoldEvent],
+            expiration_datetime: T.nilable(Time),
+            family: Lithic::Hold::Family::TaggedSymbol,
+            financial_account_token: String,
+            pending_amount: Integer,
+            result: Lithic::Hold::Result::TaggedSymbol,
+            user_defined_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Status of a hold transaction
+      module Status
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Hold::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING = T.let(:PENDING, Lithic::Hold::Status::TaggedSymbol)
+        SETTLED = T.let(:SETTLED, Lithic::Hold::Status::TaggedSymbol)
+        EXPIRED = T.let(:EXPIRED, Lithic::Hold::Status::TaggedSymbol)
+        VOIDED = T.let(:VOIDED, Lithic::Hold::Status::TaggedSymbol)
+        DECLINED = T.let(:DECLINED, Lithic::Hold::Status::TaggedSymbol)
+        REVERSED = T.let(:REVERSED, Lithic::Hold::Status::TaggedSymbol)
+        CANCELED = T.let(:CANCELED, Lithic::Hold::Status::TaggedSymbol)
+        RETURNED = T.let(:RETURNED, Lithic::Hold::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Hold::Status::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # HOLD - Hold Transaction
+      module Family
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Hold::Family) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        HOLD = T.let(:HOLD, Lithic::Hold::Family::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Hold::Family::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      module Result
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Hold::Result) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        APPROVED = T.let(:APPROVED, Lithic::Hold::Result::TaggedSymbol)
+        DECLINED = T.let(:DECLINED, Lithic::Hold::Result::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Hold::Result::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/hold_create_params.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class HoldCreateParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::HoldCreateParams, Lithic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :financial_account_token
+
+      # Amount to hold in cents
+      sig { returns(Integer) }
+      attr_accessor :amount
+
+      # Customer-provided token for idempotency. Becomes the hold token.
+      sig { returns(T.nilable(String)) }
+      attr_reader :token
+
+      sig { params(token: String).void }
+      attr_writer :token
+
+      # When the hold should auto-expire
+      sig { returns(T.nilable(Time)) }
+      attr_reader :expiration_datetime
+
+      sig { params(expiration_datetime: Time).void }
+      attr_writer :expiration_datetime
+
+      # Reason for the hold
+      sig { returns(T.nilable(String)) }
+      attr_accessor :memo
+
+      # User-provided identifier for the hold
+      sig { returns(T.nilable(String)) }
+      attr_reader :user_defined_id
+
+      sig { params(user_defined_id: String).void }
+      attr_writer :user_defined_id
+
+      sig do
+        params(
+          financial_account_token: String,
+          amount: Integer,
+          token: String,
+          expiration_datetime: Time,
+          memo: T.nilable(String),
+          user_defined_id: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        financial_account_token:,
+        # Amount to hold in cents
+        amount:,
+        # Customer-provided token for idempotency. Becomes the hold token.
+        token: nil,
+        # When the hold should auto-expire
+        expiration_datetime: nil,
+        # Reason for the hold
+        memo: nil,
+        # User-provided identifier for the hold
+        user_defined_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            financial_account_token: String,
+            amount: Integer,
+            token: String,
+            expiration_datetime: Time,
+            memo: T.nilable(String),
+            user_defined_id: String,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/hold_event.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class HoldEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Lithic::HoldEvent, Lithic::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :token
+
+      # Amount in cents
+      sig { returns(Integer) }
+      attr_accessor :amount
+
+      sig { returns(Time) }
+      attr_accessor :created
+
+      sig { returns(T::Array[Lithic::HoldEvent::DetailedResult::TaggedSymbol]) }
+      attr_accessor :detailed_results
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :memo
+
+      sig { returns(Lithic::HoldEvent::Result::TaggedSymbol) }
+      attr_accessor :result
+
+      # Transaction token of the payment that settled this hold (only populated for
+      # HOLD_SETTLED events)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :settling_transaction_token
+
+      # Type of hold lifecycle event
+      sig { returns(Lithic::HoldEvent::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      # Event representing a lifecycle change to a hold
+      sig do
+        params(
+          token: String,
+          amount: Integer,
+          created: Time,
+          detailed_results:
+            T::Array[Lithic::HoldEvent::DetailedResult::OrSymbol],
+          memo: T.nilable(String),
+          result: Lithic::HoldEvent::Result::OrSymbol,
+          settling_transaction_token: T.nilable(String),
+          type: Lithic::HoldEvent::Type::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        token:,
+        # Amount in cents
+        amount:,
+        created:,
+        detailed_results:,
+        memo:,
+        result:,
+        # Transaction token of the payment that settled this hold (only populated for
+        # HOLD_SETTLED events)
+        settling_transaction_token:,
+        # Type of hold lifecycle event
+        type:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            token: String,
+            amount: Integer,
+            created: Time,
+            detailed_results:
+              T::Array[Lithic::HoldEvent::DetailedResult::TaggedSymbol],
+            memo: T.nilable(String),
+            result: Lithic::HoldEvent::Result::TaggedSymbol,
+            settling_transaction_token: T.nilable(String),
+            type: Lithic::HoldEvent::Type::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module DetailedResult
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::HoldEvent::DetailedResult) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        APPROVED =
+          T.let(:APPROVED, Lithic::HoldEvent::DetailedResult::TaggedSymbol)
+        INSUFFICIENT_FUNDS =
+          T.let(
+            :INSUFFICIENT_FUNDS,
+            Lithic::HoldEvent::DetailedResult::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::HoldEvent::DetailedResult::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Result
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::HoldEvent::Result) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        APPROVED = T.let(:APPROVED, Lithic::HoldEvent::Result::TaggedSymbol)
+        DECLINED = T.let(:DECLINED, Lithic::HoldEvent::Result::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Lithic::HoldEvent::Result::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      # Type of hold lifecycle event
+      module Type
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::HoldEvent::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        HOLD_INITIATED =
+          T.let(:HOLD_INITIATED, Lithic::HoldEvent::Type::TaggedSymbol)
+        HOLD_VOIDED = T.let(:HOLD_VOIDED, Lithic::HoldEvent::Type::TaggedSymbol)
+        HOLD_EXPIRED =
+          T.let(:HOLD_EXPIRED, Lithic::HoldEvent::Type::TaggedSymbol)
+        HOLD_SETTLED =
+          T.let(:HOLD_SETTLED, Lithic::HoldEvent::Type::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Lithic::HoldEvent::Type::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end