lithic 0.1.0 → 0.2.0

data/rbi/lithic/models/digital_wallet_tokenization_result_webhook_event.rbi

@@ -0,0 +1,295 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DigitalWalletTokenizationResultWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::DigitalWalletTokenizationResultWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Account token
+      sig { returns(String) }
+      attr_accessor :account_token
+
+      # Card token
+      sig { returns(String) }
+      attr_accessor :card_token
+
+      # Created date
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # The result of the tokenization request.
+      sig do
+        returns(
+          Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails
+        )
+      end
+      attr_reader :tokenization_result_details
+
+      sig do
+        params(
+          tokenization_result_details:
+            Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::OrHash
+        ).void
+      end
+      attr_writer :tokenization_result_details
+
+      # Tokenization token
+      sig { returns(String) }
+      attr_accessor :tokenization_token
+
+      sig do
+        params(
+          account_token: String,
+          card_token: String,
+          created: Time,
+          tokenization_result_details:
+            Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::OrHash,
+          tokenization_token: String,
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Account token
+        account_token:,
+        # Card token
+        card_token:,
+        # Created date
+        created:,
+        # The result of the tokenization request.
+        tokenization_result_details:,
+        # Tokenization token
+        tokenization_token:,
+        # The type of event that occurred.
+        event_type: :"digital_wallet.tokenization_result"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            card_token: String,
+            created: Time,
+            event_type: Symbol,
+            tokenization_result_details:
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails,
+            tokenization_token: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class TokenizationResultDetails < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Lithic's tokenization decision.
+        sig { returns(String) }
+        attr_accessor :issuer_decision
+
+        # List of reasons why the tokenization was declined
+        sig do
+          returns(
+            T::Array[
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            ]
+          )
+        end
+        attr_accessor :tokenization_decline_reasons
+
+        # The customer's tokenization decision if applicable.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :customer_decision
+
+        # Results from rules that were evaluated for this tokenization
+        sig { returns(T.nilable(T::Array[Lithic::TokenizationRuleResult])) }
+        attr_reader :rule_results
+
+        sig do
+          params(
+            rule_results: T::Array[Lithic::TokenizationRuleResult::OrHash]
+          ).void
+        end
+        attr_writer :rule_results
+
+        # An RFC 3339 timestamp indicating when the tokenization succeeded.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :token_activated_date_time
+
+        # List of reasons why two-factor authentication was required
+        sig do
+          returns(
+            T.nilable(T::Array[Lithic::TokenizationTfaReason::TaggedSymbol])
+          )
+        end
+        attr_reader :tokenization_tfa_reasons
+
+        sig do
+          params(
+            tokenization_tfa_reasons:
+              T::Array[Lithic::TokenizationTfaReason::OrSymbol]
+          ).void
+        end
+        attr_writer :tokenization_tfa_reasons
+
+        # The wallet's recommended decision.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :wallet_decision
+
+        # The result of the tokenization request.
+        sig do
+          params(
+            issuer_decision: String,
+            tokenization_decline_reasons:
+              T::Array[
+                Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::OrSymbol
+              ],
+            customer_decision: T.nilable(String),
+            rule_results: T::Array[Lithic::TokenizationRuleResult::OrHash],
+            token_activated_date_time: T.nilable(Time),
+            tokenization_tfa_reasons:
+              T::Array[Lithic::TokenizationTfaReason::OrSymbol],
+            wallet_decision: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Lithic's tokenization decision.
+          issuer_decision:,
+          # List of reasons why the tokenization was declined
+          tokenization_decline_reasons:,
+          # The customer's tokenization decision if applicable.
+          customer_decision: nil,
+          # Results from rules that were evaluated for this tokenization
+          rule_results: nil,
+          # An RFC 3339 timestamp indicating when the tokenization succeeded.
+          token_activated_date_time: nil,
+          # List of reasons why two-factor authentication was required
+          tokenization_tfa_reasons: nil,
+          # The wallet's recommended decision.
+          wallet_decision: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              issuer_decision: String,
+              tokenization_decline_reasons:
+                T::Array[
+                  Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+                ],
+              customer_decision: T.nilable(String),
+              rule_results: T::Array[Lithic::TokenizationRuleResult],
+              token_activated_date_time: T.nilable(Time),
+              tokenization_tfa_reasons:
+                T::Array[Lithic::TokenizationTfaReason::TaggedSymbol],
+              wallet_decision: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module TokenizationDeclineReason
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACCOUNT_SCORE_1 =
+            T.let(
+              :ACCOUNT_SCORE_1,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          ALL_WALLET_DECLINE_REASONS_PRESENT =
+            T.let(
+              :ALL_WALLET_DECLINE_REASONS_PRESENT,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CARD_EXPIRY_MONTH_MISMATCH =
+            T.let(
+              :CARD_EXPIRY_MONTH_MISMATCH,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CARD_EXPIRY_YEAR_MISMATCH =
+            T.let(
+              :CARD_EXPIRY_YEAR_MISMATCH,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CARD_INVALID_STATE =
+            T.let(
+              :CARD_INVALID_STATE,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CUSTOMER_RED_PATH =
+            T.let(
+              :CUSTOMER_RED_PATH,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CVC_MISMATCH =
+            T.let(
+              :CVC_MISMATCH,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          DEVICE_SCORE_1 =
+            T.let(
+              :DEVICE_SCORE_1,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          GENERIC_DECLINE =
+            T.let(
+              :GENERIC_DECLINE,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          INVALID_CUSTOMER_RESPONSE =
+            T.let(
+              :INVALID_CUSTOMER_RESPONSE,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          NETWORK_FAILURE =
+            T.let(
+              :NETWORK_FAILURE,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          WALLET_RECOMMENDED_DECISION_RED =
+            T.let(
+              :WALLET_RECOMMENDED_DECISION_RED,
+              Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::DigitalWalletTokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/digital_wallet_tokenization_two_factor_authentication_code_sent_webhook_event.rbi

@@ -0,0 +1,186 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the user tokenizing a card
+      sig { returns(String) }
+      attr_accessor :account_token
+
+      sig do
+        returns(
+          Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod
+        )
+      end
+      attr_reader :activation_method
+
+      sig do
+        params(
+          activation_method:
+            Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::OrHash
+        ).void
+      end
+      attr_writer :activation_method
+
+      # Unique identifier for the card being tokenized
+      sig { returns(String) }
+      attr_accessor :card_token
+
+      # Indicate when the request was received from Mastercard or Visa
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # Unique identifier for the tokenization
+      sig { returns(String) }
+      attr_accessor :tokenization_token
+
+      sig do
+        params(
+          account_token: String,
+          activation_method:
+            Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::OrHash,
+          card_token: String,
+          created: Time,
+          tokenization_token: String,
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the user tokenizing a card
+        account_token:,
+        activation_method:,
+        # Unique identifier for the card being tokenized
+        card_token:,
+        # Indicate when the request was received from Mastercard or Visa
+        created:,
+        # Unique identifier for the tokenization
+        tokenization_token:,
+        # The type of event that occurred.
+        event_type: :"digital_wallet.tokenization_two_factor_authentication_code_sent"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            activation_method:
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod,
+            card_token: String,
+            created: Time,
+            event_type: Symbol,
+            tokenization_token: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class ActivationMethod < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # The communication method that the user has selected to use to receive the
+        # authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
+        # = "EMAIL_TO_CARDHOLDER_ADDRESS"
+        sig do
+          returns(
+            Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type::TaggedSymbol
+          )
+        end
+        attr_accessor :type
+
+        # The location to which the authentication code was sent. The format depends on
+        # the ActivationMethod.Type field. If Type is Email, the Value will be the email
+        # address. If the Type is Sms, the Value will be the phone number.
+        sig { returns(String) }
+        attr_accessor :value
+
+        sig do
+          params(
+            type:
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type::OrSymbol,
+            value: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The communication method that the user has selected to use to receive the
+          # authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
+          # = "EMAIL_TO_CARDHOLDER_ADDRESS"
+          type:,
+          # The location to which the authentication code was sent. The format depends on
+          # the ActivationMethod.Type field. If Type is Email, the Value will be the email
+          # address. If the Type is Sms, the Value will be the phone number.
+          value:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              type:
+                Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type::TaggedSymbol,
+              value: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The communication method that the user has selected to use to receive the
+        # authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
+        # = "EMAIL_TO_CARDHOLDER_ADDRESS"
+        module Type
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EMAIL_TO_CARDHOLDER_ADDRESS =
+            T.let(
+              :EMAIL_TO_CARDHOLDER_ADDRESS,
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type::TaggedSymbol
+            )
+          TEXT_TO_CARDHOLDER_NUMBER =
+            T.let(
+              :TEXT_TO_CARDHOLDER_NUMBER,
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/digital_wallet_tokenization_two_factor_authentication_code_webhook_event.rbi

@@ -0,0 +1,194 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the user tokenizing a card
+      sig { returns(String) }
+      attr_accessor :account_token
+
+      sig do
+        returns(
+          Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod
+        )
+      end
+      attr_reader :activation_method
+
+      sig do
+        params(
+          activation_method:
+            Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::OrHash
+        ).void
+      end
+      attr_writer :activation_method
+
+      # Authentication code to provide to the user tokenizing a card.
+      sig { returns(String) }
+      attr_accessor :authentication_code
+
+      # Unique identifier for the card being tokenized
+      sig { returns(String) }
+      attr_accessor :card_token
+
+      # Indicate when the request was received from Mastercard or Visa
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # Unique identifier for the tokenization
+      sig { returns(String) }
+      attr_accessor :tokenization_token
+
+      sig do
+        params(
+          account_token: String,
+          activation_method:
+            Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::OrHash,
+          authentication_code: String,
+          card_token: String,
+          created: Time,
+          tokenization_token: String,
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the user tokenizing a card
+        account_token:,
+        activation_method:,
+        # Authentication code to provide to the user tokenizing a card.
+        authentication_code:,
+        # Unique identifier for the card being tokenized
+        card_token:,
+        # Indicate when the request was received from Mastercard or Visa
+        created:,
+        # Unique identifier for the tokenization
+        tokenization_token:,
+        # The type of event that occurred.
+        event_type: :"digital_wallet.tokenization_two_factor_authentication_code"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            activation_method:
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod,
+            authentication_code: String,
+            card_token: String,
+            created: Time,
+            event_type: Symbol,
+            tokenization_token: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class ActivationMethod < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # The communication method that the user has selected to use to receive the
+        # authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
+        # = "EMAIL_TO_CARDHOLDER_ADDRESS"
+        sig do
+          returns(
+            Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type::TaggedSymbol
+          )
+        end
+        attr_accessor :type
+
+        # The location where the user wants to receive the authentication code. The format
+        # depends on the ActivationMethod.Type field. If Type is Email, the Value will be
+        # the email address. If the Type is Sms, the Value will be the phone number.
+        sig { returns(String) }
+        attr_accessor :value
+
+        sig do
+          params(
+            type:
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type::OrSymbol,
+            value: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The communication method that the user has selected to use to receive the
+          # authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
+          # = "EMAIL_TO_CARDHOLDER_ADDRESS"
+          type:,
+          # The location where the user wants to receive the authentication code. The format
+          # depends on the ActivationMethod.Type field. If Type is Email, the Value will be
+          # the email address. If the Type is Sms, the Value will be the phone number.
+          value:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              type:
+                Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type::TaggedSymbol,
+              value: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The communication method that the user has selected to use to receive the
+        # authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
+        # = "EMAIL_TO_CARDHOLDER_ADDRESS"
+        module Type
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EMAIL_TO_CARDHOLDER_ADDRESS =
+            T.let(
+              :EMAIL_TO_CARDHOLDER_ADDRESS,
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type::TaggedSymbol
+            )
+          TEXT_TO_CARDHOLDER_NUMBER =
+            T.let(
+              :TEXT_TO_CARDHOLDER_NUMBER,
+              Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::DigitalWalletTokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end