lithic 0.18.1 → 0.20.0

data/rbi/lithic/models/blockchain_recipient.rbi

@@ -0,0 +1,209 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class BlockchainRecipient < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::BlockchainRecipient, Lithic::Internal::AnyHash)
+        end
+
+      # A globally unique identifier for this blockchain recipient
+      sig { returns(String) }
+      attr_accessor :token
+
+      # The financial account the blockchain recipient belongs to, or null when the
+      # recipient is registered against the program rather than a financial account
+      sig { returns(T.nilable(String)) }
+      attr_accessor :account_token
+
+      # An optional tag or memo used by some chains to identify the destination of a
+      # transfer within a shared address
+      sig { returns(T.nilable(String)) }
+      attr_accessor :address_tag
+
+      # The blockchain network that the address belongs to
+      sig { returns(String) }
+      attr_accessor :chain
+
+      # An ISO 8601 string representing when this blockchain recipient was created
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # The identifier the recipient is registered under with the payment provider
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_id
+
+      # The nickname for this blockchain recipient
+      sig { returns(T.nilable(String)) }
+      attr_accessor :name
+
+      # Legal name of the business or individual who owns the blockchain address
+      sig { returns(String) }
+      attr_accessor :owner
+
+      # Owner Type
+      sig { returns(Lithic::OwnerType::TaggedSymbol) }
+      attr_accessor :owner_type
+
+      # Globally unique identifier for the program the blockchain recipient is
+      # associated with
+      sig { returns(String) }
+      attr_accessor :program_id
+
+      # Account State
+      sig { returns(Lithic::BlockchainRecipient::State::TaggedSymbol) }
+      attr_accessor :state
+
+      # An ISO 8601 string representing when this blockchain recipient was last updated
+      sig { returns(Time) }
+      attr_accessor :updated
+
+      # Verification State
+      sig do
+        returns(Lithic::BlockchainRecipient::VerificationState::TaggedSymbol)
+      end
+      attr_accessor :verification_state
+
+      sig do
+        params(
+          token: String,
+          account_token: T.nilable(String),
+          address_tag: T.nilable(String),
+          chain: String,
+          created: Time,
+          external_id: T.nilable(String),
+          name: T.nilable(String),
+          owner: String,
+          owner_type: Lithic::OwnerType::OrSymbol,
+          program_id: String,
+          state: Lithic::BlockchainRecipient::State::OrSymbol,
+          updated: Time,
+          verification_state:
+            Lithic::BlockchainRecipient::VerificationState::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A globally unique identifier for this blockchain recipient
+        token:,
+        # The financial account the blockchain recipient belongs to, or null when the
+        # recipient is registered against the program rather than a financial account
+        account_token:,
+        # An optional tag or memo used by some chains to identify the destination of a
+        # transfer within a shared address
+        address_tag:,
+        # The blockchain network that the address belongs to
+        chain:,
+        # An ISO 8601 string representing when this blockchain recipient was created
+        created:,
+        # The identifier the recipient is registered under with the payment provider
+        external_id:,
+        # The nickname for this blockchain recipient
+        name:,
+        # Legal name of the business or individual who owns the blockchain address
+        owner:,
+        # Owner Type
+        owner_type:,
+        # Globally unique identifier for the program the blockchain recipient is
+        # associated with
+        program_id:,
+        # Account State
+        state:,
+        # An ISO 8601 string representing when this blockchain recipient was last updated
+        updated:,
+        # Verification State
+        verification_state:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            token: String,
+            account_token: T.nilable(String),
+            address_tag: T.nilable(String),
+            chain: String,
+            created: Time,
+            external_id: T.nilable(String),
+            name: T.nilable(String),
+            owner: String,
+            owner_type: Lithic::OwnerType::TaggedSymbol,
+            program_id: String,
+            state: Lithic::BlockchainRecipient::State::TaggedSymbol,
+            updated: Time,
+            verification_state:
+              Lithic::BlockchainRecipient::VerificationState::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Account State
+      module State
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::BlockchainRecipient::State) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ENABLED =
+          T.let(:ENABLED, Lithic::BlockchainRecipient::State::TaggedSymbol)
+        CLOSED =
+          T.let(:CLOSED, Lithic::BlockchainRecipient::State::TaggedSymbol)
+        PAUSED =
+          T.let(:PAUSED, Lithic::BlockchainRecipient::State::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::BlockchainRecipient::State::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Verification State
+      module VerificationState
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::BlockchainRecipient::VerificationState)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING =
+          T.let(
+            :PENDING,
+            Lithic::BlockchainRecipient::VerificationState::TaggedSymbol
+          )
+        ENABLED =
+          T.let(
+            :ENABLED,
+            Lithic::BlockchainRecipient::VerificationState::TaggedSymbol
+          )
+        FAILED_VERIFICATION =
+          T.let(
+            :FAILED_VERIFICATION,
+            Lithic::BlockchainRecipient::VerificationState::TaggedSymbol
+          )
+        INSUFFICIENT_FUNDS =
+          T.let(
+            :INSUFFICIENT_FUNDS,
+            Lithic::BlockchainRecipient::VerificationState::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::BlockchainRecipient::VerificationState::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/blockchain_recipient_create_params.rbi

@@ -0,0 +1,102 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class BlockchainRecipientCreateParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::BlockchainRecipientCreateParams,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The financial account the blockchain recipient belongs to
+      sig { returns(String) }
+      attr_accessor :account_token
+
+      # The blockchain address funds will be withdrawn to
+      sig { returns(String) }
+      attr_accessor :address
+
+      # The blockchain network that the address belongs to
+      sig { returns(String) }
+      attr_accessor :chain
+
+      # Legal name of the business or individual who owns the blockchain address
+      sig { returns(String) }
+      attr_accessor :owner
+
+      # Owner Type
+      sig { returns(Lithic::OwnerType::OrSymbol) }
+      attr_accessor :owner_type
+
+      # An optional tag or memo used by some chains to identify the destination of a
+      # transfer within a shared address
+      sig { returns(T.nilable(String)) }
+      attr_reader :address_tag
+
+      sig { params(address_tag: String).void }
+      attr_writer :address_tag
+
+      # The nickname for this blockchain recipient
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      sig do
+        params(
+          account_token: String,
+          address: String,
+          chain: String,
+          owner: String,
+          owner_type: Lithic::OwnerType::OrSymbol,
+          address_tag: String,
+          name: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The financial account the blockchain recipient belongs to
+        account_token:,
+        # The blockchain address funds will be withdrawn to
+        address:,
+        # The blockchain network that the address belongs to
+        chain:,
+        # Legal name of the business or individual who owns the blockchain address
+        owner:,
+        # Owner Type
+        owner_type:,
+        # An optional tag or memo used by some chains to identify the destination of a
+        # transfer within a shared address
+        address_tag: nil,
+        # The nickname for this blockchain recipient
+        name: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            address: String,
+            chain: String,
+            owner: String,
+            owner_type: Lithic::OwnerType::OrSymbol,
+            address_tag: String,
+            name: String,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/book_transfer_create_params.rbi

@@ -197,6 +197,11 @@ module Lithic
             :PROGRAM_FUNDING,
             Lithic::BookTransferCreateParams::Category::TaggedSymbol
           )
+        PROGRAM_TRANSFER =
+          T.let(
+            :PROGRAM_TRANSFER,
+            Lithic::BookTransferCreateParams::Category::TaggedSymbol
+          )
         TRANSFER =
           T.let(
             :TRANSFER,
@@ -311,6 +316,11 @@ module Lithic
             :BILL_PAYMENT,
             Lithic::BookTransferCreateParams::Type::TaggedSymbol
           )
+        PAYMENT_FEE =
+          T.let(
+            :PAYMENT_FEE,
+            Lithic::BookTransferCreateParams::Type::TaggedSymbol
+          )
         CASH_BACK =
           T.let(
             :CASH_BACK,
@@ -377,6 +387,16 @@ module Lithic
             :COLLECTION,
             Lithic::BookTransferCreateParams::Type::TaggedSymbol
           )
+        LITHIC_PROGRAM_TRANSFER =
+          T.let(
+            :LITHIC_PROGRAM_TRANSFER,
+            Lithic::BookTransferCreateParams::Type::TaggedSymbol
+          )
+        BANK_PROGRAM_TRANSFER =
+          T.let(
+            :BANK_PROGRAM_TRANSFER,
+            Lithic::BookTransferCreateParams::Type::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/rbi/lithic/models/book_transfer_list_params.rbi

@@ -216,6 +216,11 @@ module Lithic
             :PROGRAM_FUNDING,
             Lithic::BookTransferListParams::Category::TaggedSymbol
           )
+        PROGRAM_TRANSFER =
+          T.let(
+            :PROGRAM_TRANSFER,
+            Lithic::BookTransferListParams::Category::TaggedSymbol
+          )
         TRANSFER =
           T.let(
             :TRANSFER,

data/rbi/lithic/models/book_transfer_response.rbi

@@ -219,6 +219,11 @@ module Lithic
             :PROGRAM_FUNDING,
             Lithic::BookTransferResponse::Category::TaggedSymbol
           )
+        PROGRAM_TRANSFER =
+          T.let(
+            :PROGRAM_TRANSFER,
+            Lithic::BookTransferResponse::Category::TaggedSymbol
+          )
         TRANSFER =
           T.let(:TRANSFER, Lithic::BookTransferResponse::Category::TaggedSymbol)
 
@@ -512,6 +517,11 @@ module Lithic
               :BILL_PAYMENT,
               Lithic::BookTransferResponse::Event::Type::TaggedSymbol
             )
+          PAYMENT_FEE =
+            T.let(
+              :PAYMENT_FEE,
+              Lithic::BookTransferResponse::Event::Type::TaggedSymbol
+            )
           CASH_BACK =
             T.let(
               :CASH_BACK,
@@ -587,6 +597,16 @@ module Lithic
               :COLLECTION,
               Lithic::BookTransferResponse::Event::Type::TaggedSymbol
             )
+          LITHIC_PROGRAM_TRANSFER =
+            T.let(
+              :LITHIC_PROGRAM_TRANSFER,
+              Lithic::BookTransferResponse::Event::Type::TaggedSymbol
+            )
+          BANK_PROGRAM_TRANSFER =
+            T.let(
+              :BANK_PROGRAM_TRANSFER,
+              Lithic::BookTransferResponse::Event::Type::TaggedSymbol
+            )
 
           sig do
             override.returns(

data/rbi/lithic/models/card.rbi

@@ -5,7 +5,7 @@ module Lithic
     class Card < Lithic::Models::NonPCICard
       OrHash = T.type_alias { T.any(Lithic::Card, Lithic::Internal::AnyHash) }
 
-      # Three digit cvv printed on the back of the card.
+      # Three or four digit CVV printed on the card. Amex cards use four digit CVVs
       sig { returns(T.nilable(String)) }
       attr_reader :cvv
 
@@ -24,7 +24,7 @@ module Lithic
       # Card details with potentially PCI sensitive information for Enterprise customers
       sig { params(cvv: String, pan: String).returns(T.attached_class) }
       def self.new(
-        # Three digit cvv printed on the back of the card.
+        # Three or four digit CVV printed on the card. Amex cards use four digit CVVs
         cvv: nil,
         # Primary Account Number (PAN) (i.e. the card number). Customers must be PCI
         # compliant to have PAN returned as a field in production. Please contact

data/rbi/lithic/models/card_provision_params.rbi

@@ -24,18 +24,20 @@ module Lithic
       sig { params(certificate: String).void }
       attr_writer :certificate
 
-      # Only applicable if `digital_wallet` is `GOOGLE_PAY` or `SAMSUNG_PAY` and the
-      # card is on the Visa network. Stable device identification set by the wallet
-      # provider.
+      # Only applicable if `digital_wallet` is `GOOGLE_PAY` or `SAMSUNG_PAY`. Stable
+      # device identification set by the wallet provider. Required for both wallets
+      # regardless of network, though the value is only used for cards on the Visa
+      # network and is ignored on Amex and Mastercard.
       sig { returns(T.nilable(String)) }
       attr_reader :client_device_id
 
       sig { params(client_device_id: String).void }
       attr_writer :client_device_id
 
-      # Only applicable if `digital_wallet` is `GOOGLE_PAY` or `SAMSUNG_PAY` and the
-      # card is on the Visa network. Consumer ID that identifies the wallet account
-      # holder entity.
+      # Only applicable if `digital_wallet` is `GOOGLE_PAY` or `SAMSUNG_PAY`. Consumer
+      # ID that identifies the wallet account holder entity. Required for both wallets
+      # regardless of network, though the value is only used for cards on the Visa
+      # network and is ignored on Amex and Mastercard.
       sig { returns(T.nilable(String)) }
       attr_reader :client_wallet_account_id
 
@@ -92,13 +94,15 @@ module Lithic
         # encoded in PEM format with headers `(-----BEGIN CERTIFICATE-----)` and trailers
         # omitted. Provided by the device's wallet.
         certificate: nil,
-        # Only applicable if `digital_wallet` is `GOOGLE_PAY` or `SAMSUNG_PAY` and the
-        # card is on the Visa network. Stable device identification set by the wallet
-        # provider.
+        # Only applicable if `digital_wallet` is `GOOGLE_PAY` or `SAMSUNG_PAY`. Stable
+        # device identification set by the wallet provider. Required for both wallets
+        # regardless of network, though the value is only used for cards on the Visa
+        # network and is ignored on Amex and Mastercard.
         client_device_id: nil,
-        # Only applicable if `digital_wallet` is `GOOGLE_PAY` or `SAMSUNG_PAY` and the
-        # card is on the Visa network. Consumer ID that identifies the wallet account
-        # holder entity.
+        # Only applicable if `digital_wallet` is `GOOGLE_PAY` or `SAMSUNG_PAY`. Consumer
+        # ID that identifies the wallet account holder entity. Required for both wallets
+        # regardless of network, though the value is only used for cards on the Visa
+        # network and is ignored on Amex and Mastercard.
         client_wallet_account_id: nil,
         # Name of digital wallet provider.
         digital_wallet: nil,

data/rbi/lithic/models/card_reassign_account_params.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardReassignAccountParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CardReassignAccountParams, Lithic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :card_token
+
+      # Globally unique identifier for the account to associate with the card
+      sig { returns(String) }
+      attr_accessor :new_account_token
+
+      sig do
+        params(
+          card_token: String,
+          new_account_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        card_token:,
+        # Globally unique identifier for the account to associate with the card
+        new_account_token:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            card_token: String,
+            new_account_token: String,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end