lithic 0.1.0.pre.alpha.56 → 0.2.0

data/lib/lithic/models/tokenization_decisioning_request_webhook_event.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Models
+    class TokenizationDecisioningRequestWebhookEvent < Lithic::Internal::Type::BaseModel
+      # @!attribute account_token
+      #   Unique identifier for the user tokenizing a card
+      #
+      #   @return [String]
+      required :account_token, String
+
+      # @!attribute card_token
+      #   Unique identifier for the card being tokenized
+      #
+      #   @return [String]
+      required :card_token, String
+
+      # @!attribute created
+      #   Indicate when the request was received from Mastercard or Visa
+      #
+      #   @return [Time]
+      required :created, Time
+
+      # @!attribute event_type
+      #   The name of this event
+      #
+      #   @return [Symbol, Lithic::Models::TokenizationDecisioningRequestWebhookEvent::EventType]
+      required :event_type, enum: -> { Lithic::TokenizationDecisioningRequestWebhookEvent::EventType }
+
+      # @!attribute issuer_decision
+      #   Whether Lithic decisioned on the token, and if so, what the decision was.
+      #   APPROVED/VERIFICATION_REQUIRED/DENIED.
+      #
+      #   @return [Symbol, Lithic::Models::TokenizationDecisioningRequestWebhookEvent::IssuerDecision]
+      required :issuer_decision, enum: -> { Lithic::TokenizationDecisioningRequestWebhookEvent::IssuerDecision }
+
+      # @!attribute tokenization_channel
+      #   The channel through which the tokenization was made.
+      #
+      #   @return [Symbol, Lithic::Models::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel]
+      required :tokenization_channel,
+               enum: -> { Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel }
+
+      # @!attribute tokenization_token
+      #   Unique identifier for the digital wallet token attempt
+      #
+      #   @return [String]
+      required :tokenization_token, String
+
+      # @!attribute wallet_decisioning_info
+      #
+      #   @return [Lithic::Models::WalletDecisioningInfo]
+      required :wallet_decisioning_info, -> { Lithic::WalletDecisioningInfo }
+
+      # @!attribute device
+      #
+      #   @return [Lithic::Models::Device, nil]
+      optional :device, -> { Lithic::Device }
+
+      # @!attribute digital_wallet_token_metadata
+      #   Contains the metadata for the digital wallet being tokenized.
+      #
+      #   @return [Lithic::Models::DigitalWalletTokenMetadata, nil]
+      optional :digital_wallet_token_metadata, -> { Lithic::DigitalWalletTokenMetadata }
+
+      # @!attribute tokenization_source
+      #   The source of the tokenization.
+      #
+      #   @return [Symbol, Lithic::Models::TokenizationDecisioningRequestWebhookEvent::TokenizationSource, nil]
+      optional :tokenization_source,
+               enum: -> { Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource }
+
+      # @!method initialize(account_token:, card_token:, created:, event_type:, issuer_decision:, tokenization_channel:, tokenization_token:, wallet_decisioning_info:, device: nil, digital_wallet_token_metadata: nil, tokenization_source: nil)
+      #   Some parameter documentations has been truncated, see
+      #   {Lithic::Models::TokenizationDecisioningRequestWebhookEvent} for more details.
+      #
+      #   A webhook for tokenization decisioning sent to the customer's responder endpoint
+      #
+      #   @param account_token [String] Unique identifier for the user tokenizing a card
+      #
+      #   @param card_token [String] Unique identifier for the card being tokenized
+      #
+      #   @param created [Time] Indicate when the request was received from Mastercard or Visa
+      #
+      #   @param event_type [Symbol, Lithic::Models::TokenizationDecisioningRequestWebhookEvent::EventType] The name of this event
+      #
+      #   @param issuer_decision [Symbol, Lithic::Models::TokenizationDecisioningRequestWebhookEvent::IssuerDecision] Whether Lithic decisioned on the token, and if so, what the decision was. APPROV
+      #
+      #   @param tokenization_channel [Symbol, Lithic::Models::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel] The channel through which the tokenization was made.
+      #
+      #   @param tokenization_token [String] Unique identifier for the digital wallet token attempt
+      #
+      #   @param wallet_decisioning_info [Lithic::Models::WalletDecisioningInfo]
+      #
+      #   @param device [Lithic::Models::Device]
+      #
+      #   @param digital_wallet_token_metadata [Lithic::Models::DigitalWalletTokenMetadata] Contains the metadata for the digital wallet being tokenized.
+      #
+      #   @param tokenization_source [Symbol, Lithic::Models::TokenizationDecisioningRequestWebhookEvent::TokenizationSource] The source of the tokenization.
+
+      # The name of this event
+      #
+      # @see Lithic::Models::TokenizationDecisioningRequestWebhookEvent#event_type
+      module EventType
+        extend Lithic::Internal::Type::Enum
+
+        DIGITAL_WALLET_TOKENIZATION_APPROVAL_REQUEST = :"digital_wallet.tokenization_approval_request"
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # Whether Lithic decisioned on the token, and if so, what the decision was.
+      # APPROVED/VERIFICATION_REQUIRED/DENIED.
+      #
+      # @see Lithic::Models::TokenizationDecisioningRequestWebhookEvent#issuer_decision
+      module IssuerDecision
+        extend Lithic::Internal::Type::Enum
+
+        APPROVED = :APPROVED
+        DENIED = :DENIED
+        VERIFICATION_REQUIRED = :VERIFICATION_REQUIRED
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # The channel through which the tokenization was made.
+      #
+      # @see Lithic::Models::TokenizationDecisioningRequestWebhookEvent#tokenization_channel
+      module TokenizationChannel
+        extend Lithic::Internal::Type::Enum
+
+        DIGITAL_WALLET = :DIGITAL_WALLET
+        MERCHANT = :MERCHANT
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # The source of the tokenization.
+      #
+      # @see Lithic::Models::TokenizationDecisioningRequestWebhookEvent#tokenization_source
+      module TokenizationSource
+        extend Lithic::Internal::Type::Enum
+
+        ACCOUNT_ON_FILE = :ACCOUNT_ON_FILE
+        CONTACTLESS_TAP = :CONTACTLESS_TAP
+        MANUAL_PROVISION = :MANUAL_PROVISION
+        PUSH_PROVISION = :PUSH_PROVISION
+        TOKEN = :TOKEN
+        UNKNOWN = :UNKNOWN
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/lithic/models/tokenization_decline_reason.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Models
+    # Reason code for why a tokenization was declined
+    module TokenizationDeclineReason
+      extend Lithic::Internal::Type::Enum
+
+      ACCOUNT_SCORE_1 = :ACCOUNT_SCORE_1
+      DEVICE_SCORE_1 = :DEVICE_SCORE_1
+      ALL_WALLET_DECLINE_REASONS_PRESENT = :ALL_WALLET_DECLINE_REASONS_PRESENT
+      WALLET_RECOMMENDED_DECISION_RED = :WALLET_RECOMMENDED_DECISION_RED
+      CVC_MISMATCH = :CVC_MISMATCH
+      CARD_EXPIRY_MONTH_MISMATCH = :CARD_EXPIRY_MONTH_MISMATCH
+      CARD_EXPIRY_YEAR_MISMATCH = :CARD_EXPIRY_YEAR_MISMATCH
+      CARD_INVALID_STATE = :CARD_INVALID_STATE
+      CUSTOMER_RED_PATH = :CUSTOMER_RED_PATH
+      INVALID_CUSTOMER_RESPONSE = :INVALID_CUSTOMER_RESPONSE
+      NETWORK_FAILURE = :NETWORK_FAILURE
+      GENERIC_DECLINE = :GENERIC_DECLINE
+      DIGITAL_CARD_ART_REQUIRED = :DIGITAL_CARD_ART_REQUIRED
+
+      # @!method self.values
+      #   @return [Array<Symbol>]
+    end
+  end
+end

data/lib/lithic/models/tokenization_result_webhook_event.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Models
+    class TokenizationResultWebhookEvent < Lithic::Internal::Type::BaseModel
+      # @!attribute account_token
+      #   Account token
+      #
+      #   @return [String]
+      required :account_token, String
+
+      # @!attribute card_token
+      #   Card token
+      #
+      #   @return [String]
+      required :card_token, String
+
+      # @!attribute created
+      #   Created date
+      #
+      #   @return [Time]
+      required :created, Time
+
+      # @!attribute event_type
+      #   The type of event that occurred.
+      #
+      #   @return [Symbol, :"tokenization.result"]
+      required :event_type, const: :"tokenization.result"
+
+      # @!attribute tokenization_result_details
+      #   The result of the tokenization request.
+      #
+      #   @return [Lithic::Models::TokenizationResultWebhookEvent::TokenizationResultDetails]
+      required :tokenization_result_details,
+               -> { Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails }
+
+      # @!attribute tokenization_token
+      #   Tokenization token
+      #
+      #   @return [String]
+      required :tokenization_token, String
+
+      # @!method initialize(account_token:, card_token:, created:, tokenization_result_details:, tokenization_token:, event_type: :"tokenization.result")
+      #   @param account_token [String] Account token
+      #
+      #   @param card_token [String] Card token
+      #
+      #   @param created [Time] Created date
+      #
+      #   @param tokenization_result_details [Lithic::Models::TokenizationResultWebhookEvent::TokenizationResultDetails] The result of the tokenization request.
+      #
+      #   @param tokenization_token [String] Tokenization token
+      #
+      #   @param event_type [Symbol, :"tokenization.result"] The type of event that occurred.
+
+      # @see Lithic::Models::TokenizationResultWebhookEvent#tokenization_result_details
+      class TokenizationResultDetails < Lithic::Internal::Type::BaseModel
+        # @!attribute issuer_decision
+        #   Lithic's tokenization decision.
+        #
+        #   @return [String]
+        required :issuer_decision, String
+
+        # @!attribute tokenization_decline_reasons
+        #   List of reasons why the tokenization was declined
+        #
+        #   @return [Array<Symbol, Lithic::Models::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason>]
+        required :tokenization_decline_reasons,
+                 -> { Lithic::Internal::Type::ArrayOf[enum: Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason] }
+
+        # @!attribute customer_decision
+        #   The customer's tokenization decision if applicable.
+        #
+        #   @return [String, nil]
+        optional :customer_decision, String, nil?: true
+
+        # @!attribute rule_results
+        #   Results from rules that were evaluated for this tokenization
+        #
+        #   @return [Array<Lithic::Models::TokenizationRuleResult>, nil]
+        optional :rule_results, -> { Lithic::Internal::Type::ArrayOf[Lithic::TokenizationRuleResult] }
+
+        # @!attribute token_activated_date_time
+        #   An RFC 3339 timestamp indicating when the tokenization succeeded.
+        #
+        #   @return [Time, nil]
+        optional :token_activated_date_time, Time, nil?: true
+
+        # @!attribute tokenization_tfa_reasons
+        #   List of reasons why two-factor authentication was required
+        #
+        #   @return [Array<Symbol, Lithic::Models::TokenizationTfaReason>, nil]
+        optional :tokenization_tfa_reasons,
+                 -> { Lithic::Internal::Type::ArrayOf[enum: Lithic::TokenizationTfaReason] }
+
+        # @!attribute wallet_decision
+        #   The wallet's recommended decision.
+        #
+        #   @return [String, nil]
+        optional :wallet_decision, String, nil?: true
+
+        # @!method initialize(issuer_decision:, tokenization_decline_reasons:, customer_decision: nil, rule_results: nil, token_activated_date_time: nil, tokenization_tfa_reasons: nil, wallet_decision: nil)
+        #   The result of the tokenization request.
+        #
+        #   @param issuer_decision [String] Lithic's tokenization decision.
+        #
+        #   @param tokenization_decline_reasons [Array<Symbol, Lithic::Models::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason>] List of reasons why the tokenization was declined
+        #
+        #   @param customer_decision [String, nil] The customer's tokenization decision if applicable.
+        #
+        #   @param rule_results [Array<Lithic::Models::TokenizationRuleResult>] Results from rules that were evaluated for this tokenization
+        #
+        #   @param token_activated_date_time [Time, nil] An RFC 3339 timestamp indicating when the tokenization succeeded.
+        #
+        #   @param tokenization_tfa_reasons [Array<Symbol, Lithic::Models::TokenizationTfaReason>] List of reasons why two-factor authentication was required
+        #
+        #   @param wallet_decision [String, nil] The wallet's recommended decision.
+
+        module TokenizationDeclineReason
+          extend Lithic::Internal::Type::Enum
+
+          ACCOUNT_SCORE_1 = :ACCOUNT_SCORE_1
+          ALL_WALLET_DECLINE_REASONS_PRESENT = :ALL_WALLET_DECLINE_REASONS_PRESENT
+          CARD_EXPIRY_MONTH_MISMATCH = :CARD_EXPIRY_MONTH_MISMATCH
+          CARD_EXPIRY_YEAR_MISMATCH = :CARD_EXPIRY_YEAR_MISMATCH
+          CARD_INVALID_STATE = :CARD_INVALID_STATE
+          CUSTOMER_RED_PATH = :CUSTOMER_RED_PATH
+          CVC_MISMATCH = :CVC_MISMATCH
+          DEVICE_SCORE_1 = :DEVICE_SCORE_1
+          GENERIC_DECLINE = :GENERIC_DECLINE
+          INVALID_CUSTOMER_RESPONSE = :INVALID_CUSTOMER_RESPONSE
+          NETWORK_FAILURE = :NETWORK_FAILURE
+          WALLET_RECOMMENDED_DECISION_RED = :WALLET_RECOMMENDED_DECISION_RED
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+      end
+    end
+  end
+end

data/lib/lithic/models/tokenization_rule_result.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Models
+    class TokenizationRuleResult < Lithic::Internal::Type::BaseModel
+      # @!attribute auth_rule_token
+      #   The Auth Rule Token associated with the rule. If this is set to null, then the
+      #   result was not associated with a customer-configured rule. This may happen in
+      #   cases where a tokenization is declined or requires TFA due to a
+      #   Lithic-configured security or compliance rule, for example.
+      #
+      #   @return [String, nil]
+      required :auth_rule_token, String, nil?: true
+
+      # @!attribute explanation
+      #   A human-readable explanation outlining the motivation for the rule's result
+      #
+      #   @return [String, nil]
+      required :explanation, String, nil?: true
+
+      # @!attribute name
+      #   The name for the rule, if any was configured
+      #
+      #   @return [String, nil]
+      required :name, String, nil?: true
+
+      # @!attribute result
+      #   The result associated with this rule
+      #
+      #   @return [Symbol, Lithic::Models::TokenizationRuleResult::Result]
+      required :result, enum: -> { Lithic::TokenizationRuleResult::Result }
+
+      # @!method initialize(auth_rule_token:, explanation:, name:, result:)
+      #   Some parameter documentations has been truncated, see
+      #   {Lithic::Models::TokenizationRuleResult} for more details.
+      #
+      #   @param auth_rule_token [String, nil] The Auth Rule Token associated with the rule. If this is set to null, then the r
+      #
+      #   @param explanation [String, nil] A human-readable explanation outlining the motivation for the rule's result
+      #
+      #   @param name [String, nil] The name for the rule, if any was configured
+      #
+      #   @param result [Symbol, Lithic::Models::TokenizationRuleResult::Result] The result associated with this rule
+
+      # The result associated with this rule
+      #
+      # @see Lithic::Models::TokenizationRuleResult#result
+      module Result
+        extend Lithic::Internal::Type::Enum
+
+        APPROVED = :APPROVED
+        DECLINED = :DECLINED
+        REQUIRE_TFA = :REQUIRE_TFA
+        ERROR = :ERROR
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/lithic/models/tokenization_tfa_reason.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Models
+    # Reason code for why a tokenization required two-factor authentication
+    module TokenizationTfaReason
+      extend Lithic::Internal::Type::Enum
+
+      WALLET_RECOMMENDED_TFA = :WALLET_RECOMMENDED_TFA
+      SUSPICIOUS_ACTIVITY = :SUSPICIOUS_ACTIVITY
+      DEVICE_RECENTLY_LOST = :DEVICE_RECENTLY_LOST
+      TOO_MANY_RECENT_ATTEMPTS = :TOO_MANY_RECENT_ATTEMPTS
+      TOO_MANY_RECENT_TOKENS = :TOO_MANY_RECENT_TOKENS
+      TOO_MANY_DIFFERENT_CARDHOLDERS = :TOO_MANY_DIFFERENT_CARDHOLDERS
+      OUTSIDE_HOME_TERRITORY = :OUTSIDE_HOME_TERRITORY
+      HAS_SUSPENDED_TOKENS = :HAS_SUSPENDED_TOKENS
+      HIGH_RISK = :HIGH_RISK
+      ACCOUNT_SCORE_LOW = :ACCOUNT_SCORE_LOW
+      DEVICE_SCORE_LOW = :DEVICE_SCORE_LOW
+      CARD_STATE_TFA = :CARD_STATE_TFA
+      HARDCODED_TFA = :HARDCODED_TFA
+      CUSTOMER_RULE_TFA = :CUSTOMER_RULE_TFA
+      DEVICE_HOST_CARD_EMULATION = :DEVICE_HOST_CARD_EMULATION
+
+      # @!method self.values
+      #   @return [Array<Symbol>]
+    end
+  end
+end

data/lib/lithic/models/tokenization_two_factor_authentication_code_sent_webhook_event.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Models
+    class TokenizationTwoFactorAuthenticationCodeSentWebhookEvent < Lithic::Internal::Type::BaseModel
+      # @!attribute account_token
+      #   Unique identifier for the user tokenizing a card
+      #
+      #   @return [String]
+      required :account_token, String
+
+      # @!attribute activation_method
+      #
+      #   @return [Lithic::Models::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod]
+      required :activation_method,
+               -> { Lithic::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod }
+
+      # @!attribute card_token
+      #   Unique identifier for the card being tokenized
+      #
+      #   @return [String]
+      required :card_token, String
+
+      # @!attribute created
+      #   Indicate when the request was received from Mastercard or Visa
+      #
+      #   @return [Time]
+      required :created, Time
+
+      # @!attribute event_type
+      #   The type of event that occurred.
+      #
+      #   @return [Symbol, :"tokenization.two_factor_authentication_code_sent"]
+      required :event_type, const: :"tokenization.two_factor_authentication_code_sent"
+
+      # @!attribute tokenization_token
+      #   Unique identifier for the tokenization
+      #
+      #   @return [String]
+      required :tokenization_token, String
+
+      # @!method initialize(account_token:, activation_method:, card_token:, created:, tokenization_token:, event_type: :"tokenization.two_factor_authentication_code_sent")
+      #   @param account_token [String] Unique identifier for the user tokenizing a card
+      #
+      #   @param activation_method [Lithic::Models::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod]
+      #
+      #   @param card_token [String] Unique identifier for the card being tokenized
+      #
+      #   @param created [Time] Indicate when the request was received from Mastercard or Visa
+      #
+      #   @param tokenization_token [String] Unique identifier for the tokenization
+      #
+      #   @param event_type [Symbol, :"tokenization.two_factor_authentication_code_sent"] The type of event that occurred.
+
+      # @see Lithic::Models::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent#activation_method
+      class ActivationMethod < Lithic::Internal::Type::BaseModel
+        # @!attribute type
+        #   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"
+        #
+        #   @return [Symbol, Lithic::Models::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type]
+        required :type,
+                 enum: -> { Lithic::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type }
+
+        # @!attribute value
+        #   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.
+        #
+        #   @return [String]
+        required :value, String
+
+        # @!method initialize(type:, value:)
+        #   Some parameter documentations has been truncated, see
+        #   {Lithic::Models::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod}
+        #   for more details.
+        #
+        #   @param type [Symbol, Lithic::Models::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type] The communication method that the user has selected to use to receive the authen
+        #
+        #   @param value [String] The location to which the authentication code was sent.
+
+        # 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"
+        #
+        # @see Lithic::Models::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod#type
+        module Type
+          extend Lithic::Internal::Type::Enum
+
+          EMAIL_TO_CARDHOLDER_ADDRESS = :EMAIL_TO_CARDHOLDER_ADDRESS
+          TEXT_TO_CARDHOLDER_NUMBER = :TEXT_TO_CARDHOLDER_NUMBER
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+      end
+    end
+  end
+end

data/lib/lithic/models/tokenization_two_factor_authentication_code_webhook_event.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Models
+    class TokenizationTwoFactorAuthenticationCodeWebhookEvent < Lithic::Internal::Type::BaseModel
+      # @!attribute account_token
+      #   Unique identifier for the user tokenizing a card
+      #
+      #   @return [String]
+      required :account_token, String
+
+      # @!attribute activation_method
+      #
+      #   @return [Lithic::Models::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod]
+      required :activation_method,
+               -> { Lithic::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod }
+
+      # @!attribute authentication_code
+      #   Authentication code to provide to the user tokenizing a card.
+      #
+      #   @return [String]
+      required :authentication_code, String
+
+      # @!attribute card_token
+      #   Unique identifier for the card being tokenized
+      #
+      #   @return [String]
+      required :card_token, String
+
+      # @!attribute created
+      #   Indicate when the request was received from Mastercard or Visa
+      #
+      #   @return [Time]
+      required :created, Time
+
+      # @!attribute event_type
+      #   The type of event that occurred.
+      #
+      #   @return [Symbol, :"tokenization.two_factor_authentication_code"]
+      required :event_type, const: :"tokenization.two_factor_authentication_code"
+
+      # @!attribute tokenization_token
+      #   Unique identifier for the tokenization
+      #
+      #   @return [String]
+      required :tokenization_token, String
+
+      # @!method initialize(account_token:, activation_method:, authentication_code:, card_token:, created:, tokenization_token:, event_type: :"tokenization.two_factor_authentication_code")
+      #   @param account_token [String] Unique identifier for the user tokenizing a card
+      #
+      #   @param activation_method [Lithic::Models::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod]
+      #
+      #   @param authentication_code [String] Authentication code to provide to the user tokenizing a card.
+      #
+      #   @param card_token [String] Unique identifier for the card being tokenized
+      #
+      #   @param created [Time] Indicate when the request was received from Mastercard or Visa
+      #
+      #   @param tokenization_token [String] Unique identifier for the tokenization
+      #
+      #   @param event_type [Symbol, :"tokenization.two_factor_authentication_code"] The type of event that occurred.
+
+      # @see Lithic::Models::TokenizationTwoFactorAuthenticationCodeWebhookEvent#activation_method
+      class ActivationMethod < Lithic::Internal::Type::BaseModel
+        # @!attribute type
+        #   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"
+        #
+        #   @return [Symbol, Lithic::Models::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type]
+        required :type,
+                 enum: -> { Lithic::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type }
+
+        # @!attribute value
+        #   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.
+        #
+        #   @return [String]
+        required :value, String
+
+        # @!method initialize(type:, value:)
+        #   Some parameter documentations has been truncated, see
+        #   {Lithic::Models::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod}
+        #   for more details.
+        #
+        #   @param type [Symbol, Lithic::Models::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type] The communication method that the user has selected to use to receive the authen
+        #
+        #   @param value [String] The location where the user wants to receive the authentication code.
+
+        # 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"
+        #
+        # @see Lithic::Models::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod#type
+        module Type
+          extend Lithic::Internal::Type::Enum
+
+          EMAIL_TO_CARDHOLDER_ADDRESS = :EMAIL_TO_CARDHOLDER_ADDRESS
+          TEXT_TO_CARDHOLDER_NUMBER = :TEXT_TO_CARDHOLDER_NUMBER
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+      end
+    end
+  end
+end

data/lib/lithic/models/tokenization_updated_webhook_event.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Models
+    class TokenizationUpdatedWebhookEvent < Lithic::Internal::Type::BaseModel
+      # @!attribute account_token
+      #   Account token
+      #
+      #   @return [String]
+      required :account_token, String
+
+      # @!attribute card_token
+      #   Card token
+      #
+      #   @return [String]
+      required :card_token, String
+
+      # @!attribute created
+      #   Created date
+      #
+      #   @return [Time]
+      required :created, Time
+
+      # @!attribute event_type
+      #   The type of event that occurred.
+      #
+      #   @return [Symbol, :"tokenization.updated"]
+      required :event_type, const: :"tokenization.updated"
+
+      # @!attribute tokenization
+      #
+      #   @return [Lithic::Models::Tokenization]
+      required :tokenization, -> { Lithic::Tokenization }
+
+      # @!method initialize(account_token:, card_token:, created:, tokenization:, event_type: :"tokenization.updated")
+      #   @param account_token [String] Account token
+      #
+      #   @param card_token [String] Card token
+      #
+      #   @param created [Time] Created date
+      #
+      #   @param tokenization [Lithic::Models::Tokenization]
+      #
+      #   @param event_type [Symbol, :"tokenization.updated"] The type of event that occurred.
+    end
+  end
+end