lithic 0.5.0 → 0.6.0

data/rbi/lithic/models/tokenization_approval_request_webhook_event.rbi

@@ -60,6 +60,13 @@ module Lithic
       end
       attr_accessor :issuer_decision
 
+      # Contains the metadata for the digital wallet being tokenized.
+      sig { returns(Lithic::TokenMetadata) }
+      attr_reader :token_metadata
+
+      sig { params(token_metadata: Lithic::TokenMetadata::OrHash).void }
+      attr_writer :token_metadata
+
       # The channel through which the tokenization was made.
       sig do
         returns(
@@ -88,18 +95,6 @@ module Lithic
       sig { params(device: Lithic::Device::OrHash).void }
       attr_writer :device
 
-      # Contains the metadata for the digital wallet being tokenized.
-      sig { returns(T.nilable(Lithic::DigitalWalletTokenMetadata)) }
-      attr_reader :digital_wallet_token_metadata
-
-      sig do
-        params(
-          digital_wallet_token_metadata:
-            Lithic::DigitalWalletTokenMetadata::OrHash
-        ).void
-      end
-      attr_writer :digital_wallet_token_metadata
-
       # Results from rules that were evaluated for this tokenization
       sig { returns(T.nilable(T::Array[Lithic::TokenizationRuleResult])) }
       attr_reader :rule_results
@@ -174,13 +169,12 @@ module Lithic
             Lithic::TokenizationApprovalRequestWebhookEvent::EventType::OrSymbol,
           issuer_decision:
             Lithic::TokenizationApprovalRequestWebhookEvent::IssuerDecision::OrSymbol,
+          token_metadata: Lithic::TokenMetadata::OrHash,
           tokenization_channel:
             Lithic::TokenizationApprovalRequestWebhookEvent::TokenizationChannel::OrSymbol,
           tokenization_token: String,
           wallet_decisioning_info: Lithic::WalletDecisioningInfo::OrHash,
           device: Lithic::Device::OrHash,
-          digital_wallet_token_metadata:
-            Lithic::DigitalWalletTokenMetadata::OrHash,
           rule_results: T::Array[Lithic::TokenizationRuleResult::OrHash],
           tokenization_decline_reasons:
             T::Array[Lithic::TokenizationDeclineReason::OrSymbol],
@@ -204,14 +198,14 @@ module Lithic
         # Whether Lithic decisioned on the token, and if so, what the decision was.
         # APPROVED/VERIFICATION_REQUIRED/DENIED.
         issuer_decision:,
+        # Contains the metadata for the digital wallet being tokenized.
+        token_metadata:,
         # The channel through which the tokenization was made.
         tokenization_channel:,
         # Unique identifier for the digital wallet token attempt
         tokenization_token:,
         wallet_decisioning_info:,
         device: nil,
-        # Contains the metadata for the digital wallet being tokenized.
-        digital_wallet_token_metadata: nil,
         # Results from rules that were evaluated for this tokenization
         rule_results: nil,
         # List of reasons why the tokenization was declined
@@ -237,12 +231,12 @@ module Lithic
               Lithic::TokenizationApprovalRequestWebhookEvent::EventType::TaggedSymbol,
             issuer_decision:
               Lithic::TokenizationApprovalRequestWebhookEvent::IssuerDecision::TaggedSymbol,
+            token_metadata: Lithic::TokenMetadata,
             tokenization_channel:
               Lithic::TokenizationApprovalRequestWebhookEvent::TokenizationChannel::TaggedSymbol,
             tokenization_token: String,
             wallet_decisioning_info: Lithic::WalletDecisioningInfo,
             device: Lithic::Device,
-            digital_wallet_token_metadata: Lithic::DigitalWalletTokenMetadata,
             rule_results: T::Array[Lithic::TokenizationRuleResult],
             tokenization_decline_reasons:
               T::Array[Lithic::TokenizationDeclineReason::TaggedSymbol],

data/rbi/lithic/models/tokenization_decisioning_request_webhook_event.rbi

@@ -23,6 +23,17 @@ module Lithic
       sig { returns(Time) }
       attr_accessor :created
 
+      # Contains the metadata for the digital wallet being tokenized.
+      sig { returns(Lithic::TokenMetadata) }
+      attr_reader :digital_wallet_token_metadata
+
+      sig do
+        params(
+          digital_wallet_token_metadata: Lithic::TokenMetadata::OrHash
+        ).void
+      end
+      attr_writer :digital_wallet_token_metadata
+
       # The name of this event
       sig do
         returns(
@@ -68,18 +79,6 @@ module Lithic
       sig { params(device: Lithic::Device::OrHash).void }
       attr_writer :device
 
-      # Contains the metadata for the digital wallet being tokenized.
-      sig { returns(T.nilable(Lithic::DigitalWalletTokenMetadata)) }
-      attr_reader :digital_wallet_token_metadata
-
-      sig do
-        params(
-          digital_wallet_token_metadata:
-            Lithic::DigitalWalletTokenMetadata::OrHash
-        ).void
-      end
-      attr_writer :digital_wallet_token_metadata
-
       # The source of the tokenization.
       sig do
         returns(
@@ -104,6 +103,7 @@ module Lithic
           account_token: String,
           card_token: String,
           created: Time,
+          digital_wallet_token_metadata: Lithic::TokenMetadata::OrHash,
           event_type:
             Lithic::TokenizationDecisioningRequestWebhookEvent::EventType::OrSymbol,
           issuer_decision:
@@ -113,8 +113,6 @@ module Lithic
           tokenization_token: String,
           wallet_decisioning_info: Lithic::WalletDecisioningInfo::OrHash,
           device: Lithic::Device::OrHash,
-          digital_wallet_token_metadata:
-            Lithic::DigitalWalletTokenMetadata::OrHash,
           tokenization_source:
             Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::OrSymbol
         ).returns(T.attached_class)
@@ -126,6 +124,8 @@ module Lithic
         card_token:,
         # Indicate when the request was received from Mastercard or Visa
         created:,
+        # Contains the metadata for the digital wallet being tokenized.
+        digital_wallet_token_metadata:,
         # The name of this event
         event_type:,
         # Whether Lithic decisioned on the token, and if so, what the decision was.
@@ -137,8 +137,6 @@ module Lithic
         tokenization_token:,
         wallet_decisioning_info:,
         device: nil,
-        # Contains the metadata for the digital wallet being tokenized.
-        digital_wallet_token_metadata: nil,
         # The source of the tokenization.
         tokenization_source: nil
       )
@@ -150,6 +148,7 @@ module Lithic
             account_token: String,
             card_token: String,
             created: Time,
+            digital_wallet_token_metadata: Lithic::TokenMetadata,
             event_type:
               Lithic::TokenizationDecisioningRequestWebhookEvent::EventType::TaggedSymbol,
             issuer_decision:
@@ -159,7 +158,6 @@ module Lithic
             tokenization_token: String,
             wallet_decisioning_info: Lithic::WalletDecisioningInfo,
             device: Lithic::Device,
-            digital_wallet_token_metadata: Lithic::DigitalWalletTokenMetadata,
             tokenization_source:
               Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
           }

data/rbi/lithic/models.rbi

@@ -30,6 +30,8 @@ module Lithic
 
   AccountHolderRetrieveParams = Lithic::Models::AccountHolderRetrieveParams
 
+  AccountHolders = Lithic::Models::AccountHolders
+
   AccountHolderSimulateEnrollmentDocumentReviewParams =
     Lithic::Models::AccountHolderSimulateEnrollmentDocumentReviewParams
 
@@ -206,8 +208,6 @@ module Lithic
   DigitalWalletTokenizationUpdatedWebhookEvent =
     Lithic::Models::DigitalWalletTokenizationUpdatedWebhookEvent
 
-  DigitalWalletTokenMetadata = Lithic::Models::DigitalWalletTokenMetadata
-
   Dispute = Lithic::Models::Dispute
 
   DisputeCreateParams = Lithic::Models::DisputeCreateParams
@@ -561,6 +561,8 @@ module Lithic
   TokenizationUpdatedWebhookEvent =
     Lithic::Models::TokenizationUpdatedWebhookEvent
 
+  TokenMetadata = Lithic::Models::TokenMetadata
+
   Transaction = Lithic::Models::Transaction
 
   TransactionExpireAuthorizationParams =

data/rbi/lithic/resources/account_holders/entities.rbi

@@ -0,0 +1,80 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class AccountHolders
+      class Entities
+        # Create a new beneficial owner or replace the control person entity on an
+        # existing KYB account holder. This endpoint is only applicable for account
+        # holders enrolled through a KYB workflow with the Persona KYB provider. A new
+        # control person can only replace the existing one. A maximum of 4 beneficial
+        # owners can be associated with an account holder.
+        sig do
+          params(
+            account_holder_token: String,
+            address:
+              Lithic::AccountHolders::EntityCreateParams::Address::OrHash,
+            dob: String,
+            email: String,
+            first_name: String,
+            government_id: String,
+            last_name: String,
+            phone_number: String,
+            type: Lithic::AccountHolders::EntityCreateParams::Type::OrSymbol,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(Lithic::Models::AccountHolders::EntityCreateResponse)
+        end
+        def create(
+          # Globally unique identifier for the account holder.
+          account_holder_token,
+          # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
+          # acceptable; APO/FPO are acceptable. Only USA addresses are currently supported.
+          address:,
+          # Individual's date of birth, as an RFC 3339 date.
+          dob:,
+          # Individual's email address. If utilizing Lithic for chargeback processing, this
+          # customer email address may be used to communicate dispute status and resolution.
+          email:,
+          # Individual's first name, as it appears on government-issued identity documents.
+          first_name:,
+          # Government-issued identification number (required for identity verification and
+          # compliance with banking regulations). Social Security Numbers (SSN) and
+          # Individual Taxpayer Identification Numbers (ITIN) are currently supported,
+          # entered as full nine-digits, with or without hyphens
+          government_id:,
+          # Individual's last name, as it appears on government-issued identity documents.
+          last_name:,
+          # Individual's phone number, entered in E.164 format.
+          phone_number:,
+          # The type of entity to create on the account holder
+          type:,
+          request_options: {}
+        )
+        end
+
+        # Deactivate a beneficial owner entity on an existing KYB account holder. Only
+        # beneficial owner entities can be deactivated.
+        sig do
+          params(
+            entity_token: String,
+            account_holder_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(Lithic::AccountHolders::AccountHolderEntity)
+        end
+        def delete(
+          # Globally unique identifier for the entity.
+          entity_token,
+          # Globally unique identifier for the account holder.
+          account_holder_token:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/resources/account_holders.rbi

@@ -3,6 +3,9 @@
 module Lithic
   module Resources
     class AccountHolders
+      sig { returns(Lithic::Resources::AccountHolders::Entities) }
+      attr_reader :entities
+
       # Create an account holder and initiate the appropriate onboarding workflow.
       # Account holders and accounts have a 1:1 relationship. When an account holder is
       # successfully created an associated account is also created. All calls to this

data/rbi/lithic/resources/auth_rules/v2.rbi

@@ -39,7 +39,8 @@ module Lithic
           # several event streams, the effective one is defined by the separate
           # `event_stream` field.
           #
-          # - `CONDITIONAL_BLOCK`: AUTHORIZATION event stream.
+          # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+          #   AUTHORIZATION event stream.
           # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
           # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
           # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,

data/rbi/lithic/resources/financial_accounts/interest_tier_schedule.rbi

@@ -0,0 +1,156 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class InterestTierSchedule
+        # Create a new interest tier schedule entry for a supported financial account
+        sig do
+          params(
+            financial_account_token: String,
+            credit_product_token: String,
+            effective_date: Date,
+            tier_name: String,
+            tier_rates: T.anything,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule
+          )
+        end
+        def create(
+          # Globally unique identifier for financial account
+          financial_account_token,
+          # Globally unique identifier for a credit product
+          credit_product_token:,
+          # Date the tier should be effective in YYYY-MM-DD format
+          effective_date:,
+          # Name of a tier contained in the credit product. Mutually exclusive with
+          # tier_rates
+          tier_name: nil,
+          # Custom rates per category. Mutually exclusive with tier_name
+          tier_rates: nil,
+          request_options: {}
+        )
+        end
+
+        # Get a specific interest tier schedule by effective date
+        sig do
+          params(
+            effective_date: Date,
+            financial_account_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule
+          )
+        end
+        def retrieve(
+          # Effective date in ISO format (YYYY-MM-DD)
+          effective_date,
+          # Globally unique identifier for financial account
+          financial_account_token:,
+          request_options: {}
+        )
+        end
+
+        # Update an existing interest tier schedule
+        sig do
+          params(
+            effective_date: Date,
+            financial_account_token: String,
+            tier_name: String,
+            tier_rates: T.anything,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule
+          )
+        end
+        def update(
+          # Path param: Effective date in ISO format (YYYY-MM-DD)
+          effective_date,
+          # Path param: Globally unique identifier for financial account
+          financial_account_token:,
+          # Body param: Name of a tier contained in the credit product. Mutually exclusive
+          # with tier_rates
+          tier_name: nil,
+          # Body param: Custom rates per category. Mutually exclusive with tier_name
+          tier_rates: nil,
+          request_options: {}
+        )
+        end
+
+        # List interest tier schedules for a financial account with optional date
+        # filtering.
+        #
+        # If no date parameters are provided, returns all tier schedules. If date
+        # parameters are provided, uses filtering to return matching schedules (max 100).
+        #
+        # - for_date: Returns exact match (takes precedence over other dates)
+        # - before_date: Returns schedules with effective_date <= before_date
+        # - after_date: Returns schedules with effective_date >= after_date
+        # - Both before_date and after_date: Returns schedules in range
+        sig do
+          params(
+            financial_account_token: String,
+            after_date: Date,
+            before_date: Date,
+            for_date: Date,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::Internal::SinglePage[
+              Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule
+            ]
+          )
+        end
+        def list(
+          # Globally unique identifier for financial account
+          financial_account_token,
+          # Return schedules with effective_date >= after_date (ISO format YYYY-MM-DD)
+          after_date: nil,
+          # Return schedules with effective_date <= before_date (ISO format YYYY-MM-DD)
+          before_date: nil,
+          # Return schedule with effective_date == for_date (ISO format YYYY-MM-DD)
+          for_date: nil,
+          request_options: {}
+        )
+        end
+
+        # Delete an interest tier schedule entry.
+        #
+        # Returns:
+        #
+        # - 400 Bad Request: Invalid effective_date format OR attempting to delete the
+        #   earliest tier schedule entry for a non-PENDING account
+        # - 404 Not Found: Tier schedule entry not found for the given effective_date OR
+        #   ledger account not found
+        #
+        # Note: PENDING accounts can delete the earliest tier schedule entry (account
+        # hasn't opened yet). Active/non-PENDING accounts cannot delete the earliest entry
+        # to prevent orphaning the account.
+        #
+        # If the deleted tier schedule has a past effective_date and the account is
+        # ACTIVE, the loan tape rebuild configuration will be updated to trigger rebuilds
+        # from that date.
+        sig do
+          params(
+            effective_date: Date,
+            financial_account_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).void
+        end
+        def delete(
+          # Effective date in ISO format (YYYY-MM-DD)
+          effective_date,
+          # Globally unique identifier for financial account
+          financial_account_token:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/resources/financial_accounts/loan_tape_configuration.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class LoanTapeConfiguration
+        # Get the loan tape configuration for a given financial account.
+        sig do
+          params(
+            financial_account_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::FinancialAccounts::FinancialAccountsLoanTapeConfiguration
+          )
+        end
+        def retrieve(
+          # Globally unique identifier for financial account.
+          financial_account_token,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/resources/financial_accounts.rbi

@@ -20,6 +20,16 @@ module Lithic
       sig { returns(Lithic::Resources::FinancialAccounts::LoanTapes) }
       attr_reader :loan_tapes
 
+      sig do
+        returns(Lithic::Resources::FinancialAccounts::LoanTapeConfiguration)
+      end
+      attr_reader :loan_tape_configuration
+
+      sig do
+        returns(Lithic::Resources::FinancialAccounts::InterestTierSchedule)
+      end
+      attr_reader :interest_tier_schedule
+
       # Create a new financial account
       sig do
         params(

data/sig/lithic/models/account_holders/account_holder_entity.rbs

@@ -0,0 +1,137 @@
+module Lithic
+  module Models
+    class AccountHolderEntity = AccountHolders::AccountHolderEntity
+
+    module AccountHolders
+      type account_holder_entity =
+        {
+          token: String,
+          account_holder_token: String,
+          address: Lithic::AccountHolders::AccountHolderEntity::Address,
+          dob: String?,
+          email: String?,
+          first_name: String?,
+          last_name: String?,
+          phone_number: String?,
+          status: Lithic::Models::AccountHolders::AccountHolderEntity::status,
+          type: Lithic::Models::AccountHolders::AccountHolderEntity::type_
+        }
+
+      class AccountHolderEntity < Lithic::Internal::Type::BaseModel
+        attr_accessor token: String
+
+        attr_accessor account_holder_token: String
+
+        attr_accessor address: Lithic::AccountHolders::AccountHolderEntity::Address
+
+        attr_accessor dob: String?
+
+        attr_accessor email: String?
+
+        attr_accessor first_name: String?
+
+        attr_accessor last_name: String?
+
+        attr_accessor phone_number: String?
+
+        attr_accessor status: Lithic::Models::AccountHolders::AccountHolderEntity::status
+
+        attr_accessor type: Lithic::Models::AccountHolders::AccountHolderEntity::type_
+
+        def initialize: (
+          token: String,
+          account_holder_token: String,
+          address: Lithic::AccountHolders::AccountHolderEntity::Address,
+          dob: String?,
+          email: String?,
+          first_name: String?,
+          last_name: String?,
+          phone_number: String?,
+          status: Lithic::Models::AccountHolders::AccountHolderEntity::status,
+          type: Lithic::Models::AccountHolders::AccountHolderEntity::type_
+        ) -> void
+
+        def to_hash: -> {
+          token: String,
+          account_holder_token: String,
+          address: Lithic::AccountHolders::AccountHolderEntity::Address,
+          dob: String?,
+          email: String?,
+          first_name: String?,
+          last_name: String?,
+          phone_number: String?,
+          status: Lithic::Models::AccountHolders::AccountHolderEntity::status,
+          type: Lithic::Models::AccountHolders::AccountHolderEntity::type_
+        }
+
+        type address =
+          {
+            :address1 => String,
+            city: String,
+            country: String,
+            postal_code: String,
+            state: String,
+            :address2 => String
+          }
+
+        class Address < Lithic::Internal::Type::BaseModel
+          attr_accessor address1: String
+
+          attr_accessor city: String
+
+          attr_accessor country: String
+
+          attr_accessor postal_code: String
+
+          attr_accessor state: String
+
+          attr_reader address2: String?
+
+          def address2=: (String) -> String
+
+          def initialize: (
+            address1: String,
+            city: String,
+            country: String,
+            postal_code: String,
+            state: String,
+            ?address2: String
+          ) -> void
+
+          def to_hash: -> {
+            :address1 => String,
+            city: String,
+            country: String,
+            postal_code: String,
+            state: String,
+            :address2 => String
+          }
+        end
+
+        type status = :ACCEPTED | :INACTIVE | :PENDING_REVIEW | :REJECTED
+
+        module Status
+          extend Lithic::Internal::Type::Enum
+
+          ACCEPTED: :ACCEPTED
+          INACTIVE: :INACTIVE
+          PENDING_REVIEW: :PENDING_REVIEW
+          REJECTED: :REJECTED
+
+          def self?.values: -> ::Array[Lithic::Models::AccountHolders::AccountHolderEntity::status]
+        end
+
+        type type_ = :BENEFICIAL_OWNER_INDIVIDUAL | :CONTROL_PERSON
+
+        module Type
+          extend Lithic::Internal::Type::Enum
+
+          BENEFICIAL_OWNER_INDIVIDUAL: :BENEFICIAL_OWNER_INDIVIDUAL
+          CONTROL_PERSON: :CONTROL_PERSON
+
+          def self?.values: -> ::Array[Lithic::Models::AccountHolders::AccountHolderEntity::type_]
+        end
+      end
+    end
+  end
+end