lithic 0.19.0 → 0.21.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/blockchain_recipient_retrieve_params.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class BlockchainRecipientRetrieveParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::BlockchainRecipientRetrieveParams,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :blockchain_recipient_token
+
+      sig do
+        params(
+          blockchain_recipient_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(blockchain_recipient_token:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            blockchain_recipient_token: String,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

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_pin_updated_webhook_event.rbi

@@ -0,0 +1,166 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardPinUpdatedWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CardPinUpdatedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      # The token of the card whose PIN or PIN status was updated
+      sig { returns(String) }
+      attr_accessor :card_token
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # The card's PIN status after the update
+      sig do
+        returns(Lithic::CardPinUpdatedWebhookEvent::PinStatus::TaggedSymbol)
+      end
+      attr_accessor :pin_status
+
+      # The reason for the PIN update:
+      #
+      # - `PIN_SET` - The PIN was set for the first time; `pin_status` is `OK`
+      # - `PIN_CHANGED` - The PIN was changed, including when changing a blocked PIN;
+      #   `pin_status` is `OK`
+      # - `PIN_UNBLOCKED` - The PIN was unblocked without changing it; `pin_status` is
+      #   `OK`
+      # - `EXCESSIVE_PIN_ATTEMPTS` - The PIN was blocked due to excessive incorrect PIN
+      #   attempts; `pin_status` is `BLOCKED`
+      sig do
+        returns(Lithic::CardPinUpdatedWebhookEvent::StatusReason::TaggedSymbol)
+      end
+      attr_accessor :status_reason
+
+      sig do
+        params(
+          card_token: String,
+          pin_status: Lithic::CardPinUpdatedWebhookEvent::PinStatus::OrSymbol,
+          status_reason:
+            Lithic::CardPinUpdatedWebhookEvent::StatusReason::OrSymbol,
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The token of the card whose PIN or PIN status was updated
+        card_token:,
+        # The card's PIN status after the update
+        pin_status:,
+        # The reason for the PIN update:
+        #
+        # - `PIN_SET` - The PIN was set for the first time; `pin_status` is `OK`
+        # - `PIN_CHANGED` - The PIN was changed, including when changing a blocked PIN;
+        #   `pin_status` is `OK`
+        # - `PIN_UNBLOCKED` - The PIN was unblocked without changing it; `pin_status` is
+        #   `OK`
+        # - `EXCESSIVE_PIN_ATTEMPTS` - The PIN was blocked due to excessive incorrect PIN
+        #   attempts; `pin_status` is `BLOCKED`
+        status_reason:,
+        # The type of event that occurred.
+        event_type: :"card.pin_updated"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            card_token: String,
+            event_type: Symbol,
+            pin_status:
+              Lithic::CardPinUpdatedWebhookEvent::PinStatus::TaggedSymbol,
+            status_reason:
+              Lithic::CardPinUpdatedWebhookEvent::StatusReason::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The card's PIN status after the update
+      module PinStatus
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::CardPinUpdatedWebhookEvent::PinStatus)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        OK =
+          T.let(
+            :OK,
+            Lithic::CardPinUpdatedWebhookEvent::PinStatus::TaggedSymbol
+          )
+        BLOCKED =
+          T.let(
+            :BLOCKED,
+            Lithic::CardPinUpdatedWebhookEvent::PinStatus::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::CardPinUpdatedWebhookEvent::PinStatus::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The reason for the PIN update:
+      #
+      # - `PIN_SET` - The PIN was set for the first time; `pin_status` is `OK`
+      # - `PIN_CHANGED` - The PIN was changed, including when changing a blocked PIN;
+      #   `pin_status` is `OK`
+      # - `PIN_UNBLOCKED` - The PIN was unblocked without changing it; `pin_status` is
+      #   `OK`
+      # - `EXCESSIVE_PIN_ATTEMPTS` - The PIN was blocked due to excessive incorrect PIN
+      #   attempts; `pin_status` is `BLOCKED`
+      module StatusReason
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::CardPinUpdatedWebhookEvent::StatusReason)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PIN_SET =
+          T.let(
+            :PIN_SET,
+            Lithic::CardPinUpdatedWebhookEvent::StatusReason::TaggedSymbol
+          )
+        PIN_CHANGED =
+          T.let(
+            :PIN_CHANGED,
+            Lithic::CardPinUpdatedWebhookEvent::StatusReason::TaggedSymbol
+          )
+        PIN_UNBLOCKED =
+          T.let(
+            :PIN_UNBLOCKED,
+            Lithic::CardPinUpdatedWebhookEvent::StatusReason::TaggedSymbol
+          )
+        EXCESSIVE_PIN_ATTEMPTS =
+          T.let(
+            :EXCESSIVE_PIN_ATTEMPTS,
+            Lithic::CardPinUpdatedWebhookEvent::StatusReason::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::CardPinUpdatedWebhookEvent::StatusReason::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

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