lithic 0.20.0 → 0.21.0

data/rbi/lithic/models/payment_create_stablecoin_params.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class PaymentCreateStablecoinParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::PaymentCreateStablecoinParams,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Payout amount in cents
+      sig { returns(Integer) }
+      attr_accessor :amount
+
+      # Token of the blockchain recipient to send the payout to. The recipient must be
+      # in the `ENABLED` verification state
+      sig { returns(String) }
+      attr_accessor :blockchain_recipient_token
+
+      # Token of the financial account the payout is funded from
+      sig { returns(String) }
+      attr_accessor :financial_account_token
+
+      # Direction of the payment. Stablecoin supports payouts only
+      sig { returns(Lithic::PaymentCreateStablecoinParams::Type::OrSymbol) }
+      attr_accessor :type
+
+      # Customer-provided token that will serve as an idempotency token. This token will
+      # become the transaction token
+      sig { returns(T.nilable(String)) }
+      attr_reader :token
+
+      sig { params(token: String).void }
+      attr_writer :token
+
+      # Optional hold to settle when this payout is initiated
+      sig { returns(T.nilable(Lithic::PaymentCreateStablecoinParams::Hold)) }
+      attr_reader :hold
+
+      sig do
+        params(hold: Lithic::PaymentCreateStablecoinParams::Hold::OrHash).void
+      end
+      attr_writer :hold
+
+      # Memo recorded on the payout. Defaults to `Stablecoin payout on <chain>` when
+      # omitted
+      sig { returns(T.nilable(String)) }
+      attr_reader :memo
+
+      sig { params(memo: String).void }
+      attr_writer :memo
+
+      sig do
+        params(
+          amount: Integer,
+          blockchain_recipient_token: String,
+          financial_account_token: String,
+          type: Lithic::PaymentCreateStablecoinParams::Type::OrSymbol,
+          token: String,
+          hold: Lithic::PaymentCreateStablecoinParams::Hold::OrHash,
+          memo: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Payout amount in cents
+        amount:,
+        # Token of the blockchain recipient to send the payout to. The recipient must be
+        # in the `ENABLED` verification state
+        blockchain_recipient_token:,
+        # Token of the financial account the payout is funded from
+        financial_account_token:,
+        # Direction of the payment. Stablecoin supports payouts only
+        type:,
+        # Customer-provided token that will serve as an idempotency token. This token will
+        # become the transaction token
+        token: nil,
+        # Optional hold to settle when this payout is initiated
+        hold: nil,
+        # Memo recorded on the payout. Defaults to `Stablecoin payout on <chain>` when
+        # omitted
+        memo: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            amount: Integer,
+            blockchain_recipient_token: String,
+            financial_account_token: String,
+            type: Lithic::PaymentCreateStablecoinParams::Type::OrSymbol,
+            token: String,
+            hold: Lithic::PaymentCreateStablecoinParams::Hold,
+            memo: String,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Direction of the payment. Stablecoin supports payouts only
+      module Type
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::PaymentCreateStablecoinParams::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PAYMENT =
+          T.let(
+            :PAYMENT,
+            Lithic::PaymentCreateStablecoinParams::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::PaymentCreateStablecoinParams::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class Hold < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::PaymentCreateStablecoinParams::Hold,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Token of the hold to settle when this payout is initiated
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Optional hold to settle when this payout is initiated
+        sig { params(token: String).returns(T.attached_class) }
+        def self.new(
+          # Token of the hold to settle when this payout is initiated
+          token:
+        )
+        end
+
+        sig { override.returns({ token: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/payment_create_stablecoin_response.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class PaymentCreateStablecoinResponse < Lithic::Models::Payment
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::Models::PaymentCreateStablecoinResponse,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Balance
+      sig { returns(T.nilable(Lithic::Balance)) }
+      attr_reader :balance
+
+      sig { params(balance: Lithic::Balance::OrHash).void }
+      attr_writer :balance
+
+      # Payment transaction
+      sig { params(balance: Lithic::Balance::OrHash).returns(T.attached_class) }
+      def self.new(
+        # Balance
+        balance: nil
+      )
+      end
+
+      sig { override.returns({ balance: Lithic::Balance }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/payment_list_params.rbi

@@ -158,6 +158,8 @@ module Lithic
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         ACH = T.let(:ACH, Lithic::PaymentListParams::Category::TaggedSymbol)
+        STABLECOIN =
+          T.let(:STABLECOIN, Lithic::PaymentListParams::Category::TaggedSymbol)
 
         sig do
           override.returns(

data/rbi/lithic/models/payment_retry_params.rbi

@@ -14,22 +14,67 @@ module Lithic
       sig { returns(String) }
       attr_accessor :payment_token
 
+      # Settlement speed to retry the payment at. Defaults to the original payment's
+      # method. An `ACH_SAME_DAY` retry is rejected if the payment is for $1,000,000.00
+      # or more, or if it is submitted after the same day ACH cutoff
+      sig { returns(T.nilable(Lithic::PaymentRetryParams::Method::OrSymbol)) }
+      attr_reader :method_
+
+      sig { params(method_: Lithic::PaymentRetryParams::Method::OrSymbol).void }
+      attr_writer :method_
+
       sig do
         params(
           payment_token: String,
+          method_: Lithic::PaymentRetryParams::Method::OrSymbol,
           request_options: Lithic::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
-      def self.new(payment_token:, request_options: {})
+      def self.new(
+        payment_token:,
+        # Settlement speed to retry the payment at. Defaults to the original payment's
+        # method. An `ACH_SAME_DAY` retry is rejected if the payment is for $1,000,000.00
+        # or more, or if it is submitted after the same day ACH cutoff
+        method_: nil,
+        request_options: {}
+      )
       end
 
       sig do
         override.returns(
-          { payment_token: String, request_options: Lithic::RequestOptions }
+          {
+            payment_token: String,
+            method_: Lithic::PaymentRetryParams::Method::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
         )
       end
       def to_hash
       end
+
+      # Settlement speed to retry the payment at. Defaults to the original payment's
+      # method. An `ACH_SAME_DAY` retry is rejected if the payment is for $1,000,000.00
+      # or more, or if it is submitted after the same day ACH cutoff
+      module Method
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::PaymentRetryParams::Method) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACH_NEXT_DAY =
+          T.let(:ACH_NEXT_DAY, Lithic::PaymentRetryParams::Method::TaggedSymbol)
+        ACH_SAME_DAY =
+          T.let(:ACH_SAME_DAY, Lithic::PaymentRetryParams::Method::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::PaymentRetryParams::Method::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/lithic/models/payment_simulate_action_params.rbi

@@ -163,6 +163,11 @@ module Lithic
             :ACH_RETURN_SETTLED,
             Lithic::PaymentSimulateActionParams::EventType::TaggedSymbol
           )
+        STABLECOIN_REVIEWED =
+          T.let(
+            :STABLECOIN_REVIEWED,
+            Lithic::PaymentSimulateActionParams::EventType::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/rbi/lithic/models/three_ds_authentication.rbi

@@ -183,6 +183,20 @@ module Lithic
       end
       attr_accessor :decision_made_by
 
+      # PSD2/SCA context for EEA and UK transactions. Present when Lithic determines the
+      # transaction is in scope for PSD2 Strong Customer Authentication. Absent for
+      # out-of-scope transactions.
+      sig { returns(T.nilable(Lithic::ThreeDSAuthentication::Psd2Context)) }
+      attr_reader :psd2_context
+
+      sig do
+        params(
+          psd2_context:
+            T.nilable(Lithic::ThreeDSAuthentication::Psd2Context::OrHash)
+        ).void
+      end
+      attr_writer :psd2_context
+
       # Type of 3DS Requestor Initiated (3RI) request — i.e., a 3DS authentication that
       # takes place at the initiation of the merchant rather than the cardholder. The
       # most common example of this is where a merchant is authenticating before billing
@@ -245,6 +259,8 @@ module Lithic
             ),
           decision_made_by:
             T.nilable(Lithic::ThreeDSAuthentication::DecisionMadeBy::OrSymbol),
+          psd2_context:
+            T.nilable(Lithic::ThreeDSAuthentication::Psd2Context::OrHash),
           three_ri_request_type:
             T.nilable(
               Lithic::ThreeDSAuthentication::ThreeRiRequestType::OrSymbol
@@ -319,6 +335,10 @@ module Lithic
         # authentications for which a decision has not yet been made (e.g. in-flight
         # customer decisioning request).
         decision_made_by: nil,
+        # PSD2/SCA context for EEA and UK transactions. Present when Lithic determines the
+        # transaction is in scope for PSD2 Strong Customer Authentication. Absent for
+        # out-of-scope transactions.
+        psd2_context: nil,
         # Type of 3DS Requestor Initiated (3RI) request — i.e., a 3DS authentication that
         # takes place at the initiation of the merchant rather than the cardholder. The
         # most common example of this is where a merchant is authenticating before billing
@@ -370,6 +390,7 @@ module Lithic
               T.nilable(
                 Lithic::ThreeDSAuthentication::DecisionMadeBy::TaggedSymbol
               ),
+            psd2_context: T.nilable(Lithic::ThreeDSAuthentication::Psd2Context),
             three_ri_request_type:
               T.nilable(
                 Lithic::ThreeDSAuthentication::ThreeRiRequestType::TaggedSymbol
@@ -2171,6 +2192,277 @@ module Lithic
         end
       end
 
+      class Psd2Context < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::ThreeDSAuthentication::Psd2Context,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # SCA exemption declared by the acquirer in the 3DS authentication request.
+        #
+        # - `NONE` - No exemption claimed
+        # - `TRANSACTION_RISK_ANALYSIS` - Transaction Risk Analysis (TRA) exemption;
+        #   acquirer asserts low fraud risk
+        # - `LOW_VALUE` - Low-value payment exemption; transaction is below the EUR 30
+        #   threshold
+        # - `RECURRING_PAYMENT` - Recurring payment with a fixed amount to the same payee
+        # - `MERCHANT_INITIATED_TRANSACTION` - Merchant-initiated transaction (MIT);
+        #   cardholder not present
+        # - `TRUSTED_BENEFICIARY` - Trusted beneficiary; merchant is on cardholder's
+        #   whitelist
+        # - `STRONG_CUSTOMER_AUTHENTICATION_DELEGATION` - SCA already performed by a
+        #   delegated third-party authenticator
+        # - `SECURE_CORPORATE_PAYMENT` - Secure corporate payment using a dedicated
+        #   corporate card or process
+        # - `AUTHENTICATION_OUTAGE_EXCEPTION` - Authentication outage exception;
+        #   scheme-level fallback during ACS downtime
+        # - `BUNDLED` - Mastercard only; bundled exemption code where the exact exemption
+        #   type cannot be distinguished
+        sig do
+          returns(
+            T.nilable(
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          )
+        end
+        attr_reader :acquirer_exemption
+
+        sig do
+          params(
+            acquirer_exemption:
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::OrSymbol
+          ).void
+        end
+        attr_writer :acquirer_exemption
+
+        # Lithic's validation of the acquirer-declared exemption. Absent when no acquirer
+        # exemption was declared.
+        #
+        # - `ACCEPTED` - Lithic signals support the acquirer's claim
+        # - `REJECTED` - Lithic signals contradict the claim, or a required signal is
+        #   missing
+        # - `NOT_VALIDATED` - Exemption was declared but Lithic has no basis to evaluate
+        #   it; treated as `REJECTED` for challenge purposes
+        sig do
+          returns(
+            T.nilable(
+              Lithic::ThreeDSAuthentication::Psd2Context::LithicExemptionValidation::TaggedSymbol
+            )
+          )
+        end
+        attr_reader :lithic_exemption_validation
+
+        sig do
+          params(
+            lithic_exemption_validation:
+              Lithic::ThreeDSAuthentication::Psd2Context::LithicExemptionValidation::OrSymbol
+          ).void
+        end
+        attr_writer :lithic_exemption_validation
+
+        # PSD2/SCA context for EEA and UK transactions. Present when Lithic determines the
+        # transaction is in scope for PSD2 Strong Customer Authentication. Absent for
+        # out-of-scope transactions.
+        sig do
+          params(
+            acquirer_exemption:
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::OrSymbol,
+            lithic_exemption_validation:
+              Lithic::ThreeDSAuthentication::Psd2Context::LithicExemptionValidation::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # SCA exemption declared by the acquirer in the 3DS authentication request.
+          #
+          # - `NONE` - No exemption claimed
+          # - `TRANSACTION_RISK_ANALYSIS` - Transaction Risk Analysis (TRA) exemption;
+          #   acquirer asserts low fraud risk
+          # - `LOW_VALUE` - Low-value payment exemption; transaction is below the EUR 30
+          #   threshold
+          # - `RECURRING_PAYMENT` - Recurring payment with a fixed amount to the same payee
+          # - `MERCHANT_INITIATED_TRANSACTION` - Merchant-initiated transaction (MIT);
+          #   cardholder not present
+          # - `TRUSTED_BENEFICIARY` - Trusted beneficiary; merchant is on cardholder's
+          #   whitelist
+          # - `STRONG_CUSTOMER_AUTHENTICATION_DELEGATION` - SCA already performed by a
+          #   delegated third-party authenticator
+          # - `SECURE_CORPORATE_PAYMENT` - Secure corporate payment using a dedicated
+          #   corporate card or process
+          # - `AUTHENTICATION_OUTAGE_EXCEPTION` - Authentication outage exception;
+          #   scheme-level fallback during ACS downtime
+          # - `BUNDLED` - Mastercard only; bundled exemption code where the exact exemption
+          #   type cannot be distinguished
+          acquirer_exemption: nil,
+          # Lithic's validation of the acquirer-declared exemption. Absent when no acquirer
+          # exemption was declared.
+          #
+          # - `ACCEPTED` - Lithic signals support the acquirer's claim
+          # - `REJECTED` - Lithic signals contradict the claim, or a required signal is
+          #   missing
+          # - `NOT_VALIDATED` - Exemption was declared but Lithic has no basis to evaluate
+          #   it; treated as `REJECTED` for challenge purposes
+          lithic_exemption_validation: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              acquirer_exemption:
+                Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol,
+              lithic_exemption_validation:
+                Lithic::ThreeDSAuthentication::Psd2Context::LithicExemptionValidation::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # SCA exemption declared by the acquirer in the 3DS authentication request.
+        #
+        # - `NONE` - No exemption claimed
+        # - `TRANSACTION_RISK_ANALYSIS` - Transaction Risk Analysis (TRA) exemption;
+        #   acquirer asserts low fraud risk
+        # - `LOW_VALUE` - Low-value payment exemption; transaction is below the EUR 30
+        #   threshold
+        # - `RECURRING_PAYMENT` - Recurring payment with a fixed amount to the same payee
+        # - `MERCHANT_INITIATED_TRANSACTION` - Merchant-initiated transaction (MIT);
+        #   cardholder not present
+        # - `TRUSTED_BENEFICIARY` - Trusted beneficiary; merchant is on cardholder's
+        #   whitelist
+        # - `STRONG_CUSTOMER_AUTHENTICATION_DELEGATION` - SCA already performed by a
+        #   delegated third-party authenticator
+        # - `SECURE_CORPORATE_PAYMENT` - Secure corporate payment using a dedicated
+        #   corporate card or process
+        # - `AUTHENTICATION_OUTAGE_EXCEPTION` - Authentication outage exception;
+        #   scheme-level fallback during ACS downtime
+        # - `BUNDLED` - Mastercard only; bundled exemption code where the exact exemption
+        #   type cannot be distinguished
+        module AcquirerExemption
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          NONE =
+            T.let(
+              :NONE,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          TRANSACTION_RISK_ANALYSIS =
+            T.let(
+              :TRANSACTION_RISK_ANALYSIS,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          LOW_VALUE =
+            T.let(
+              :LOW_VALUE,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          RECURRING_PAYMENT =
+            T.let(
+              :RECURRING_PAYMENT,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          MERCHANT_INITIATED_TRANSACTION =
+            T.let(
+              :MERCHANT_INITIATED_TRANSACTION,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          TRUSTED_BENEFICIARY =
+            T.let(
+              :TRUSTED_BENEFICIARY,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          STRONG_CUSTOMER_AUTHENTICATION_DELEGATION =
+            T.let(
+              :STRONG_CUSTOMER_AUTHENTICATION_DELEGATION,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          SECURE_CORPORATE_PAYMENT =
+            T.let(
+              :SECURE_CORPORATE_PAYMENT,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          AUTHENTICATION_OUTAGE_EXCEPTION =
+            T.let(
+              :AUTHENTICATION_OUTAGE_EXCEPTION,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+          BUNDLED =
+            T.let(
+              :BUNDLED,
+              Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::ThreeDSAuthentication::Psd2Context::AcquirerExemption::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # Lithic's validation of the acquirer-declared exemption. Absent when no acquirer
+        # exemption was declared.
+        #
+        # - `ACCEPTED` - Lithic signals support the acquirer's claim
+        # - `REJECTED` - Lithic signals contradict the claim, or a required signal is
+        #   missing
+        # - `NOT_VALIDATED` - Exemption was declared but Lithic has no basis to evaluate
+        #   it; treated as `REJECTED` for challenge purposes
+        module LithicExemptionValidation
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::ThreeDSAuthentication::Psd2Context::LithicExemptionValidation
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACCEPTED =
+            T.let(
+              :ACCEPTED,
+              Lithic::ThreeDSAuthentication::Psd2Context::LithicExemptionValidation::TaggedSymbol
+            )
+          REJECTED =
+            T.let(
+              :REJECTED,
+              Lithic::ThreeDSAuthentication::Psd2Context::LithicExemptionValidation::TaggedSymbol
+            )
+          NOT_VALIDATED =
+            T.let(
+              :NOT_VALIDATED,
+              Lithic::ThreeDSAuthentication::Psd2Context::LithicExemptionValidation::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::ThreeDSAuthentication::Psd2Context::LithicExemptionValidation::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
       # Type of 3DS Requestor Initiated (3RI) request — i.e., a 3DS authentication that
       # takes place at the initiation of the merchant rather than the cardholder. The
       # most common example of this is where a merchant is authenticating before billing

data/rbi/lithic/models/transaction.rbi

@@ -2079,6 +2079,11 @@ module Lithic
               :REVERSAL_UNMATCHED,
               Lithic::Transaction::Event::DetailedResult::TaggedSymbol
             )
+          SCA_REQUIRED =
+            T.let(
+              :SCA_REQUIRED,
+              Lithic::Transaction::Event::DetailedResult::TaggedSymbol
+            )
           SECURITY_VIOLATION =
             T.let(
               :SECURITY_VIOLATION,
@@ -2982,6 +2987,11 @@ module Lithic
                 :REVERSAL_UNMATCHED,
                 Lithic::Transaction::Event::RuleResult::Result::TaggedSymbol
               )
+            SCA_REQUIRED =
+              T.let(
+                :SCA_REQUIRED,
+                Lithic::Transaction::Event::RuleResult::Result::TaggedSymbol
+              )
             SECURITY_VIOLATION =
               T.let(
                 :SECURITY_VIOLATION,

data/rbi/lithic/models.rbi

@@ -92,6 +92,9 @@ module Lithic
   BlockchainRecipientCreateParams =
     Lithic::Models::BlockchainRecipientCreateParams
 
+  BlockchainRecipientRetrieveParams =
+    Lithic::Models::BlockchainRecipientRetrieveParams
+
   BookTransferCreateParams = Lithic::Models::BookTransferCreateParams
 
   BookTransferListParams = Lithic::Models::BookTransferListParams
@@ -150,6 +153,8 @@ module Lithic
 
   CardListParams = Lithic::Models::CardListParams
 
+  CardPinUpdatedWebhookEvent = Lithic::Models::CardPinUpdatedWebhookEvent
+
   CardProgram = Lithic::Models::CardProgram
 
   CardProgramListParams = Lithic::Models::CardProgramListParams
@@ -493,6 +498,8 @@ module Lithic
 
   PaymentCreateParams = Lithic::Models::PaymentCreateParams
 
+  PaymentCreateStablecoinParams = Lithic::Models::PaymentCreateStablecoinParams
+
   PaymentListParams = Lithic::Models::PaymentListParams
 
   PaymentRetrieveParams = Lithic::Models::PaymentRetrieveParams

data/rbi/lithic/resources/blockchain_recipients.rbi

@@ -42,6 +42,20 @@ module Lithic
       )
       end
 
+      # Get a blockchain recipient by token
+      #
+      # Use this to poll the `verification_state` after registering an address: a
+      # recipient cannot receive a payout until screening completes and moves it out of
+      # `PENDING`
+      sig do
+        params(
+          blockchain_recipient_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::BlockchainRecipient)
+      end
+      def retrieve(blockchain_recipient_token, request_options: {})
+      end
+
       # @api private
       sig { params(client: Lithic::Client).returns(T.attached_class) }
       def self.new(client:)