lithic 0.1.0 → 0.2.0

data/rbi/lithic/models/tokenization_decisioning_request_webhook_event.rbi

@@ -0,0 +1,333 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationDecisioningRequestWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::TokenizationDecisioningRequestWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the user tokenizing a card
+      sig { returns(String) }
+      attr_accessor :account_token
+
+      # 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 name of this event
+      sig do
+        returns(
+          Lithic::TokenizationDecisioningRequestWebhookEvent::EventType::TaggedSymbol
+        )
+      end
+      attr_accessor :event_type
+
+      # Whether Lithic decisioned on the token, and if so, what the decision was.
+      # APPROVED/VERIFICATION_REQUIRED/DENIED.
+      sig do
+        returns(
+          Lithic::TokenizationDecisioningRequestWebhookEvent::IssuerDecision::TaggedSymbol
+        )
+      end
+      attr_accessor :issuer_decision
+
+      # The channel through which the tokenization was made.
+      sig do
+        returns(
+          Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel::TaggedSymbol
+        )
+      end
+      attr_accessor :tokenization_channel
+
+      # Unique identifier for the digital wallet token attempt
+      sig { returns(String) }
+      attr_accessor :tokenization_token
+
+      sig { returns(Lithic::WalletDecisioningInfo) }
+      attr_reader :wallet_decisioning_info
+
+      sig do
+        params(
+          wallet_decisioning_info: Lithic::WalletDecisioningInfo::OrHash
+        ).void
+      end
+      attr_writer :wallet_decisioning_info
+
+      sig { returns(T.nilable(Lithic::Device)) }
+      attr_reader :device
+
+      sig { params(device: Lithic::Device::OrHash).void }
+      attr_writer :device
+
+      # Contains the metadata for the digital wallet being tokenized.
+      sig { returns(T.nilable(Lithic::DigitalWalletTokenMetadata)) }
+      attr_reader :digital_wallet_token_metadata
+
+      sig do
+        params(
+          digital_wallet_token_metadata:
+            Lithic::DigitalWalletTokenMetadata::OrHash
+        ).void
+      end
+      attr_writer :digital_wallet_token_metadata
+
+      # The source of the tokenization.
+      sig do
+        returns(
+          T.nilable(
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
+          )
+        )
+      end
+      attr_reader :tokenization_source
+
+      sig do
+        params(
+          tokenization_source:
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::OrSymbol
+        ).void
+      end
+      attr_writer :tokenization_source
+
+      # A webhook for tokenization decisioning sent to the customer's responder endpoint
+      sig do
+        params(
+          account_token: String,
+          card_token: String,
+          created: Time,
+          event_type:
+            Lithic::TokenizationDecisioningRequestWebhookEvent::EventType::OrSymbol,
+          issuer_decision:
+            Lithic::TokenizationDecisioningRequestWebhookEvent::IssuerDecision::OrSymbol,
+          tokenization_channel:
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel::OrSymbol,
+          tokenization_token: String,
+          wallet_decisioning_info: Lithic::WalletDecisioningInfo::OrHash,
+          device: Lithic::Device::OrHash,
+          digital_wallet_token_metadata:
+            Lithic::DigitalWalletTokenMetadata::OrHash,
+          tokenization_source:
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the user tokenizing a card
+        account_token:,
+        # Unique identifier for the card being tokenized
+        card_token:,
+        # Indicate when the request was received from Mastercard or Visa
+        created:,
+        # The name of this event
+        event_type:,
+        # Whether Lithic decisioned on the token, and if so, what the decision was.
+        # APPROVED/VERIFICATION_REQUIRED/DENIED.
+        issuer_decision:,
+        # The channel through which the tokenization was made.
+        tokenization_channel:,
+        # Unique identifier for the digital wallet token attempt
+        tokenization_token:,
+        wallet_decisioning_info:,
+        device: nil,
+        # Contains the metadata for the digital wallet being tokenized.
+        digital_wallet_token_metadata: nil,
+        # The source of the tokenization.
+        tokenization_source: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            card_token: String,
+            created: Time,
+            event_type:
+              Lithic::TokenizationDecisioningRequestWebhookEvent::EventType::TaggedSymbol,
+            issuer_decision:
+              Lithic::TokenizationDecisioningRequestWebhookEvent::IssuerDecision::TaggedSymbol,
+            tokenization_channel:
+              Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel::TaggedSymbol,
+            tokenization_token: String,
+            wallet_decisioning_info: Lithic::WalletDecisioningInfo,
+            device: Lithic::Device,
+            digital_wallet_token_metadata: Lithic::DigitalWalletTokenMetadata,
+            tokenization_source:
+              Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The name of this event
+      module EventType
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::TokenizationDecisioningRequestWebhookEvent::EventType
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DIGITAL_WALLET_TOKENIZATION_APPROVAL_REQUEST =
+          T.let(
+            :"digital_wallet.tokenization_approval_request",
+            Lithic::TokenizationDecisioningRequestWebhookEvent::EventType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::TokenizationDecisioningRequestWebhookEvent::EventType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Whether Lithic decisioned on the token, and if so, what the decision was.
+      # APPROVED/VERIFICATION_REQUIRED/DENIED.
+      module IssuerDecision
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::TokenizationDecisioningRequestWebhookEvent::IssuerDecision
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        APPROVED =
+          T.let(
+            :APPROVED,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::IssuerDecision::TaggedSymbol
+          )
+        DENIED =
+          T.let(
+            :DENIED,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::IssuerDecision::TaggedSymbol
+          )
+        VERIFICATION_REQUIRED =
+          T.let(
+            :VERIFICATION_REQUIRED,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::IssuerDecision::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::TokenizationDecisioningRequestWebhookEvent::IssuerDecision::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The channel through which the tokenization was made.
+      module TokenizationChannel
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DIGITAL_WALLET =
+          T.let(
+            :DIGITAL_WALLET,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel::TaggedSymbol
+          )
+        MERCHANT =
+          T.let(
+            :MERCHANT,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationChannel::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The source of the tokenization.
+      module TokenizationSource
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACCOUNT_ON_FILE =
+          T.let(
+            :ACCOUNT_ON_FILE,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
+          )
+        CONTACTLESS_TAP =
+          T.let(
+            :CONTACTLESS_TAP,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
+          )
+        MANUAL_PROVISION =
+          T.let(
+            :MANUAL_PROVISION,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
+          )
+        PUSH_PROVISION =
+          T.let(
+            :PUSH_PROVISION,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
+          )
+        TOKEN =
+          T.let(
+            :TOKEN,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
+          )
+        UNKNOWN =
+          T.let(
+            :UNKNOWN,
+            Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::TokenizationDecisioningRequestWebhookEvent::TokenizationSource::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/tokenization_result_webhook_event.rbi

@@ -0,0 +1,295 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationResultWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::TokenizationResultWebhookEvent,
+            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::TokenizationResultWebhookEvent::TokenizationResultDetails
+        )
+      end
+      attr_reader :tokenization_result_details
+
+      sig do
+        params(
+          tokenization_result_details:
+            Lithic::TokenizationResultWebhookEvent::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::TokenizationResultWebhookEvent::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: :"tokenization.result"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            card_token: String,
+            created: Time,
+            event_type: Symbol,
+            tokenization_result_details:
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails,
+            tokenization_token: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class TokenizationResultDetails < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TokenizationResultWebhookEvent::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::TokenizationResultWebhookEvent::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::TokenizationResultWebhookEvent::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::TokenizationResultWebhookEvent::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::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACCOUNT_SCORE_1 =
+            T.let(
+              :ACCOUNT_SCORE_1,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          ALL_WALLET_DECLINE_REASONS_PRESENT =
+            T.let(
+              :ALL_WALLET_DECLINE_REASONS_PRESENT,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CARD_EXPIRY_MONTH_MISMATCH =
+            T.let(
+              :CARD_EXPIRY_MONTH_MISMATCH,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CARD_EXPIRY_YEAR_MISMATCH =
+            T.let(
+              :CARD_EXPIRY_YEAR_MISMATCH,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CARD_INVALID_STATE =
+            T.let(
+              :CARD_INVALID_STATE,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CUSTOMER_RED_PATH =
+            T.let(
+              :CUSTOMER_RED_PATH,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          CVC_MISMATCH =
+            T.let(
+              :CVC_MISMATCH,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          DEVICE_SCORE_1 =
+            T.let(
+              :DEVICE_SCORE_1,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          GENERIC_DECLINE =
+            T.let(
+              :GENERIC_DECLINE,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          INVALID_CUSTOMER_RESPONSE =
+            T.let(
+              :INVALID_CUSTOMER_RESPONSE,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          NETWORK_FAILURE =
+            T.let(
+              :NETWORK_FAILURE,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+          WALLET_RECOMMENDED_DECISION_RED =
+            T.let(
+              :WALLET_RECOMMENDED_DECISION_RED,
+              Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::TokenizationResultWebhookEvent::TokenizationResultDetails::TokenizationDeclineReason::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end