lithic 0.1.0.pre.alpha.53 → 0.1.0.pre.alpha.55

data/rbi/lithic/models/tokenization.rbi

@@ -22,10 +22,6 @@ module Lithic
       sig { returns(Time) }
       attr_accessor :created_at
 
-      # The device identifier associated with the tokenization.
-      sig { returns(T.nilable(String)) }
-      attr_accessor :device_id
-
       # The dynamic pan assigned to the token by the network.
       sig { returns(T.nilable(String)) }
       attr_accessor :dpan
@@ -34,9 +30,10 @@ module Lithic
       sig { returns(Lithic::Tokenization::Status::TaggedSymbol) }
       attr_accessor :status
 
-      # The entity that requested the tokenization. Represents a Digital Wallet or
-      # merchant.
-      sig { returns(Lithic::Tokenization::TokenRequestorName::TaggedSymbol) }
+      # The entity that requested the tokenization. For digital wallets, this will be
+      # one of the defined wallet types. For merchant tokenizations, this will be a
+      # free-form merchant name string.
+      sig { returns(Lithic::Tokenization::TokenRequestorName::Variants) }
       attr_accessor :token_requestor_name
 
       # The network's unique reference for the tokenization.
@@ -51,15 +48,16 @@ module Lithic
       sig { returns(Time) }
       attr_accessor :updated_at
 
-      # Specifies the digital card art displayed in the user’s digital wallet after
+      # The device identifier associated with the tokenization.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :device_id
+
+      # Specifies the digital card art displayed in the user's digital wallet after
       # tokenization. This will be null if the tokenization was created without an
       # associated digital card art. See
       # [Flexible Card Art Guide](https://docs.lithic.com/docs/about-digital-wallets#flexible-card-art).
       sig { returns(T.nilable(String)) }
-      attr_reader :digital_card_art_token
-
-      sig { params(digital_card_art_token: String).void }
-      attr_writer :digital_card_art_token
+      attr_accessor :digital_card_art_token
 
       # A list of events related to the tokenization.
       sig { returns(T.nilable(T::Array[Lithic::Tokenization::Event])) }
@@ -78,16 +76,16 @@ module Lithic
           account_token: String,
           card_token: String,
           created_at: Time,
-          device_id: T.nilable(String),
           dpan: T.nilable(String),
           status: Lithic::Tokenization::Status::OrSymbol,
           token_requestor_name:
-            Lithic::Tokenization::TokenRequestorName::OrSymbol,
+            T.any(Lithic::Tokenization::TokenRequestorName::OrSymbol, String),
           token_unique_reference: String,
           tokenization_channel:
             Lithic::Tokenization::TokenizationChannel::OrSymbol,
           updated_at: Time,
-          digital_card_art_token: String,
+          device_id: T.nilable(String),
+          digital_card_art_token: T.nilable(String),
           events: T::Array[Lithic::Tokenization::Event::OrHash],
           payment_account_reference_id: T.nilable(String)
         ).returns(T.attached_class)
@@ -101,14 +99,13 @@ module Lithic
         card_token:,
         # Date and time when the tokenization first occurred. UTC time zone.
         created_at:,
-        # The device identifier associated with the tokenization.
-        device_id:,
         # The dynamic pan assigned to the token by the network.
         dpan:,
         # The status of the tokenization request
         status:,
-        # The entity that requested the tokenization. Represents a Digital Wallet or
-        # merchant.
+        # The entity that requested the tokenization. For digital wallets, this will be
+        # one of the defined wallet types. For merchant tokenizations, this will be a
+        # free-form merchant name string.
         token_requestor_name:,
         # The network's unique reference for the tokenization.
         token_unique_reference:,
@@ -116,7 +113,9 @@ module Lithic
         tokenization_channel:,
         # Latest date and time when the tokenization was updated. UTC time zone.
         updated_at:,
-        # Specifies the digital card art displayed in the user’s digital wallet after
+        # The device identifier associated with the tokenization.
+        device_id: nil,
+        # Specifies the digital card art displayed in the user's digital wallet after
         # tokenization. This will be null if the tokenization was created without an
         # associated digital card art. See
         # [Flexible Card Art Guide](https://docs.lithic.com/docs/about-digital-wallets#flexible-card-art).
@@ -135,16 +134,16 @@ module Lithic
             account_token: String,
             card_token: String,
             created_at: Time,
-            device_id: T.nilable(String),
             dpan: T.nilable(String),
             status: Lithic::Tokenization::Status::TaggedSymbol,
             token_requestor_name:
-              Lithic::Tokenization::TokenRequestorName::TaggedSymbol,
+              Lithic::Tokenization::TokenRequestorName::Variants,
             token_unique_reference: String,
             tokenization_channel:
               Lithic::Tokenization::TokenizationChannel::TaggedSymbol,
             updated_at: Time,
-            digital_card_art_token: String,
+            device_id: T.nilable(String),
+            digital_card_art_token: T.nilable(String),
             events: T::Array[Lithic::Tokenization::Event],
             payment_account_reference_id: T.nilable(String)
           }
@@ -179,10 +178,27 @@ module Lithic
         end
       end
 
-      # The entity that requested the tokenization. Represents a Digital Wallet or
-      # merchant.
+      # The entity that requested the tokenization. For digital wallets, this will be
+      # one of the defined wallet types. For merchant tokenizations, this will be a
+      # free-form merchant name string.
       module TokenRequestorName
-        extend Lithic::Internal::Type::Enum
+        extend Lithic::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Lithic::Tokenization::TokenRequestorName::TaggedSymbol,
+              String
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[Lithic::Tokenization::TokenRequestorName::Variants]
+          )
+        end
+        def self.variants
+        end
 
         TaggedSymbol =
           T.type_alias do
@@ -220,6 +236,11 @@ module Lithic
             :GARMIN_PAY,
             Lithic::Tokenization::TokenRequestorName::TaggedSymbol
           )
+        GOOGLE_PAY =
+          T.let(
+            :GOOGLE_PAY,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
         MICROSOFT_PAY =
           T.let(
             :MICROSOFT_PAY,
@@ -245,14 +266,6 @@ module Lithic
             :VISA_CHECKOUT,
             Lithic::Tokenization::TokenRequestorName::TaggedSymbol
           )
-
-        sig do
-          override.returns(
-            T::Array[Lithic::Tokenization::TokenRequestorName::TaggedSymbol]
-          )
-        end
-        def self.values
-        end
       end
 
       # The channel through which the tokenization was made.
@@ -316,6 +329,64 @@ module Lithic
         end
         attr_writer :result
 
+        # Results from rules that were evaluated for this tokenization
+        sig do
+          returns(T.nilable(T::Array[Lithic::Tokenization::Event::RuleResult]))
+        end
+        attr_reader :rule_results
+
+        sig do
+          params(
+            rule_results:
+              T::Array[Lithic::Tokenization::Event::RuleResult::OrHash]
+          ).void
+        end
+        attr_writer :rule_results
+
+        # List of reasons why the tokenization was declined
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+              ]
+            )
+          )
+        end
+        attr_reader :tokenization_decline_reasons
+
+        sig do
+          params(
+            tokenization_decline_reasons:
+              T::Array[
+                Lithic::Tokenization::Event::TokenizationDeclineReason::OrSymbol
+              ]
+          ).void
+        end
+        attr_writer :tokenization_decline_reasons
+
+        # List of reasons why two-factor authentication was required
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+              ]
+            )
+          )
+        end
+        attr_reader :tokenization_tfa_reasons
+
+        sig do
+          params(
+            tokenization_tfa_reasons:
+              T::Array[
+                Lithic::Tokenization::Event::TokenizationTfaReason::OrSymbol
+              ]
+          ).void
+        end
+        attr_writer :tokenization_tfa_reasons
+
         # Enum representing the type of tokenization event that occurred
         sig do
           returns(T.nilable(Lithic::Tokenization::Event::Type::TaggedSymbol))
@@ -330,6 +401,16 @@ module Lithic
             token: String,
             created_at: Time,
             result: Lithic::Tokenization::Event::Result::OrSymbol,
+            rule_results:
+              T::Array[Lithic::Tokenization::Event::RuleResult::OrHash],
+            tokenization_decline_reasons:
+              T::Array[
+                Lithic::Tokenization::Event::TokenizationDeclineReason::OrSymbol
+              ],
+            tokenization_tfa_reasons:
+              T::Array[
+                Lithic::Tokenization::Event::TokenizationTfaReason::OrSymbol
+              ],
             type: Lithic::Tokenization::Event::Type::OrSymbol
           ).returns(T.attached_class)
         end
@@ -340,6 +421,12 @@ module Lithic
           created_at: nil,
           # Enum representing the result of the tokenization event
           result: nil,
+          # Results from rules that were evaluated for this tokenization
+          rule_results: nil,
+          # List of reasons why the tokenization was declined
+          tokenization_decline_reasons: nil,
+          # List of reasons why two-factor authentication was required
+          tokenization_tfa_reasons: nil,
           # Enum representing the type of tokenization event that occurred
           type: nil
         )
@@ -351,6 +438,15 @@ module Lithic
               token: String,
               created_at: Time,
               result: Lithic::Tokenization::Event::Result::TaggedSymbol,
+              rule_results: T::Array[Lithic::Tokenization::Event::RuleResult],
+              tokenization_decline_reasons:
+                T::Array[
+                  Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+                ],
+              tokenization_tfa_reasons:
+                T::Array[
+                  Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+                ],
               type: Lithic::Tokenization::Event::Type::TaggedSymbol
             }
           )
@@ -430,6 +526,305 @@ module Lithic
           end
         end
 
+        class RuleResult < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::Tokenization::Event::RuleResult,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # 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.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :auth_rule_token
+
+          # A human-readable explanation outlining the motivation for the rule's result
+          sig { returns(T.nilable(String)) }
+          attr_accessor :explanation
+
+          # The name for the rule, if any was configured
+          sig { returns(T.nilable(String)) }
+          attr_accessor :name
+
+          # The result associated with this rule
+          sig do
+            returns(
+              Lithic::Tokenization::Event::RuleResult::Result::TaggedSymbol
+            )
+          end
+          attr_accessor :result
+
+          sig do
+            params(
+              auth_rule_token: T.nilable(String),
+              explanation: T.nilable(String),
+              name: T.nilable(String),
+              result: Lithic::Tokenization::Event::RuleResult::Result::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # 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.
+            auth_rule_token:,
+            # A human-readable explanation outlining the motivation for the rule's result
+            explanation:,
+            # The name for the rule, if any was configured
+            name:,
+            # The result associated with this rule
+            result:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                auth_rule_token: T.nilable(String),
+                explanation: T.nilable(String),
+                name: T.nilable(String),
+                result:
+                  Lithic::Tokenization::Event::RuleResult::Result::TaggedSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # The result associated with this rule
+          module Result
+            extend Lithic::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, Lithic::Tokenization::Event::RuleResult::Result)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            APPROVED =
+              T.let(
+                :APPROVED,
+                Lithic::Tokenization::Event::RuleResult::Result::TaggedSymbol
+              )
+            DECLINED =
+              T.let(
+                :DECLINED,
+                Lithic::Tokenization::Event::RuleResult::Result::TaggedSymbol
+              )
+            REQUIRE_TFA =
+              T.let(
+                :REQUIRE_TFA,
+                Lithic::Tokenization::Event::RuleResult::Result::TaggedSymbol
+              )
+            ERROR =
+              T.let(
+                :ERROR,
+                Lithic::Tokenization::Event::RuleResult::Result::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Lithic::Tokenization::Event::RuleResult::Result::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        # Reason code for why a tokenization was declined
+        module TokenizationDeclineReason
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::Tokenization::Event::TokenizationDeclineReason
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACCOUNT_SCORE_1 =
+            T.let(
+              :ACCOUNT_SCORE_1,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          DEVICE_SCORE_1 =
+            T.let(
+              :DEVICE_SCORE_1,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          ALL_WALLET_DECLINE_REASONS_PRESENT =
+            T.let(
+              :ALL_WALLET_DECLINE_REASONS_PRESENT,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          WALLET_RECOMMENDED_DECISION_RED =
+            T.let(
+              :WALLET_RECOMMENDED_DECISION_RED,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          CVC_MISMATCH =
+            T.let(
+              :CVC_MISMATCH,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          CARD_EXPIRY_MONTH_MISMATCH =
+            T.let(
+              :CARD_EXPIRY_MONTH_MISMATCH,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          CARD_EXPIRY_YEAR_MISMATCH =
+            T.let(
+              :CARD_EXPIRY_YEAR_MISMATCH,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          CARD_INVALID_STATE =
+            T.let(
+              :CARD_INVALID_STATE,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          CUSTOMER_RED_PATH =
+            T.let(
+              :CUSTOMER_RED_PATH,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          INVALID_CUSTOMER_RESPONSE =
+            T.let(
+              :INVALID_CUSTOMER_RESPONSE,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          NETWORK_FAILURE =
+            T.let(
+              :NETWORK_FAILURE,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          GENERIC_DECLINE =
+            T.let(
+              :GENERIC_DECLINE,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+          DIGITAL_CARD_ART_REQUIRED =
+            T.let(
+              :DIGITAL_CARD_ART_REQUIRED,
+              Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::Tokenization::Event::TokenizationDeclineReason::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # Reason code for why a tokenization required two-factor authentication
+        module TokenizationTfaReason
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::Tokenization::Event::TokenizationTfaReason)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          WALLET_RECOMMENDED_TFA =
+            T.let(
+              :WALLET_RECOMMENDED_TFA,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          SUSPICIOUS_ACTIVITY =
+            T.let(
+              :SUSPICIOUS_ACTIVITY,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          DEVICE_RECENTLY_LOST =
+            T.let(
+              :DEVICE_RECENTLY_LOST,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          TOO_MANY_RECENT_ATTEMPTS =
+            T.let(
+              :TOO_MANY_RECENT_ATTEMPTS,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          TOO_MANY_RECENT_TOKENS =
+            T.let(
+              :TOO_MANY_RECENT_TOKENS,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          TOO_MANY_DIFFERENT_CARDHOLDERS =
+            T.let(
+              :TOO_MANY_DIFFERENT_CARDHOLDERS,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          OUTSIDE_HOME_TERRITORY =
+            T.let(
+              :OUTSIDE_HOME_TERRITORY,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          HAS_SUSPENDED_TOKENS =
+            T.let(
+              :HAS_SUSPENDED_TOKENS,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          HIGH_RISK =
+            T.let(
+              :HIGH_RISK,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          ACCOUNT_SCORE_LOW =
+            T.let(
+              :ACCOUNT_SCORE_LOW,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          DEVICE_SCORE_LOW =
+            T.let(
+              :DEVICE_SCORE_LOW,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          CARD_STATE_TFA =
+            T.let(
+              :CARD_STATE_TFA,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          HARDCODED_TFA =
+            T.let(
+              :HARDCODED_TFA,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          CUSTOMER_RULE_TFA =
+            T.let(
+              :CUSTOMER_RULE_TFA,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+          DEVICE_HOST_CARD_EMULATION =
+            T.let(
+              :DEVICE_HOST_CARD_EMULATION,
+              Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::Tokenization::Event::TokenizationTfaReason::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
         # Enum representing the type of tokenization event that occurred
         module Type
           extend Lithic::Internal::Type::Enum