lithic 0.1.0.pre.alpha.56 → 0.2.0

data/rbi/lithic/models/tokenization_rule_result.rbi

@@ -0,0 +1,96 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationRuleResult < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::TokenizationRuleResult, 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 { returns(Lithic::TokenizationRuleResult::Result::TaggedSymbol) }
+      attr_accessor :result
+
+      sig do
+        params(
+          auth_rule_token: T.nilable(String),
+          explanation: T.nilable(String),
+          name: T.nilable(String),
+          result: Lithic::TokenizationRuleResult::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::TokenizationRuleResult::Result::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The result associated with this rule
+      module Result
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::TokenizationRuleResult::Result) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        APPROVED =
+          T.let(:APPROVED, Lithic::TokenizationRuleResult::Result::TaggedSymbol)
+        DECLINED =
+          T.let(:DECLINED, Lithic::TokenizationRuleResult::Result::TaggedSymbol)
+        REQUIRE_TFA =
+          T.let(
+            :REQUIRE_TFA,
+            Lithic::TokenizationRuleResult::Result::TaggedSymbol
+          )
+        ERROR =
+          T.let(:ERROR, Lithic::TokenizationRuleResult::Result::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::TokenizationRuleResult::Result::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/tokenization_tfa_reason.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Lithic
+  module Models
+    # Reason code for why a tokenization required two-factor authentication
+    module TokenizationTfaReason
+      extend Lithic::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Lithic::TokenizationTfaReason) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      WALLET_RECOMMENDED_TFA =
+        T.let(
+          :WALLET_RECOMMENDED_TFA,
+          Lithic::TokenizationTfaReason::TaggedSymbol
+        )
+      SUSPICIOUS_ACTIVITY =
+        T.let(:SUSPICIOUS_ACTIVITY, Lithic::TokenizationTfaReason::TaggedSymbol)
+      DEVICE_RECENTLY_LOST =
+        T.let(
+          :DEVICE_RECENTLY_LOST,
+          Lithic::TokenizationTfaReason::TaggedSymbol
+        )
+      TOO_MANY_RECENT_ATTEMPTS =
+        T.let(
+          :TOO_MANY_RECENT_ATTEMPTS,
+          Lithic::TokenizationTfaReason::TaggedSymbol
+        )
+      TOO_MANY_RECENT_TOKENS =
+        T.let(
+          :TOO_MANY_RECENT_TOKENS,
+          Lithic::TokenizationTfaReason::TaggedSymbol
+        )
+      TOO_MANY_DIFFERENT_CARDHOLDERS =
+        T.let(
+          :TOO_MANY_DIFFERENT_CARDHOLDERS,
+          Lithic::TokenizationTfaReason::TaggedSymbol
+        )
+      OUTSIDE_HOME_TERRITORY =
+        T.let(
+          :OUTSIDE_HOME_TERRITORY,
+          Lithic::TokenizationTfaReason::TaggedSymbol
+        )
+      HAS_SUSPENDED_TOKENS =
+        T.let(
+          :HAS_SUSPENDED_TOKENS,
+          Lithic::TokenizationTfaReason::TaggedSymbol
+        )
+      HIGH_RISK = T.let(:HIGH_RISK, Lithic::TokenizationTfaReason::TaggedSymbol)
+      ACCOUNT_SCORE_LOW =
+        T.let(:ACCOUNT_SCORE_LOW, Lithic::TokenizationTfaReason::TaggedSymbol)
+      DEVICE_SCORE_LOW =
+        T.let(:DEVICE_SCORE_LOW, Lithic::TokenizationTfaReason::TaggedSymbol)
+      CARD_STATE_TFA =
+        T.let(:CARD_STATE_TFA, Lithic::TokenizationTfaReason::TaggedSymbol)
+      HARDCODED_TFA =
+        T.let(:HARDCODED_TFA, Lithic::TokenizationTfaReason::TaggedSymbol)
+      CUSTOMER_RULE_TFA =
+        T.let(:CUSTOMER_RULE_TFA, Lithic::TokenizationTfaReason::TaggedSymbol)
+      DEVICE_HOST_CARD_EMULATION =
+        T.let(
+          :DEVICE_HOST_CARD_EMULATION,
+          Lithic::TokenizationTfaReason::TaggedSymbol
+        )
+
+      sig do
+        override.returns(T::Array[Lithic::TokenizationTfaReason::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/lithic/models/tokenization_two_factor_authentication_code_sent_webhook_event.rbi

@@ -0,0 +1,186 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationTwoFactorAuthenticationCodeSentWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the user tokenizing a card
+      sig { returns(String) }
+      attr_accessor :account_token
+
+      sig do
+        returns(
+          Lithic::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod
+        )
+      end
+      attr_reader :activation_method
+
+      sig do
+        params(
+          activation_method:
+            Lithic::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::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: :"tokenization.two_factor_authentication_code_sent"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            activation_method:
+              Lithic::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EMAIL_TO_CARDHOLDER_ADDRESS =
+            T.let(
+              :EMAIL_TO_CARDHOLDER_ADDRESS,
+              Lithic::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type::TaggedSymbol
+            )
+          TEXT_TO_CARDHOLDER_NUMBER =
+            T.let(
+              :TEXT_TO_CARDHOLDER_NUMBER,
+              Lithic::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::TokenizationTwoFactorAuthenticationCodeSentWebhookEvent::ActivationMethod::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/tokenization_two_factor_authentication_code_webhook_event.rbi

@@ -0,0 +1,194 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationTwoFactorAuthenticationCodeWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::TokenizationTwoFactorAuthenticationCodeWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the user tokenizing a card
+      sig { returns(String) }
+      attr_accessor :account_token
+
+      sig do
+        returns(
+          Lithic::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod
+        )
+      end
+      attr_reader :activation_method
+
+      sig do
+        params(
+          activation_method:
+            Lithic::TokenizationTwoFactorAuthenticationCodeWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeWebhookEvent::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: :"tokenization.two_factor_authentication_code"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            activation_method:
+              Lithic::TokenizationTwoFactorAuthenticationCodeWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeWebhookEvent::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::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EMAIL_TO_CARDHOLDER_ADDRESS =
+            T.let(
+              :EMAIL_TO_CARDHOLDER_ADDRESS,
+              Lithic::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type::TaggedSymbol
+            )
+          TEXT_TO_CARDHOLDER_NUMBER =
+            T.let(
+              :TEXT_TO_CARDHOLDER_NUMBER,
+              Lithic::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::TokenizationTwoFactorAuthenticationCodeWebhookEvent::ActivationMethod::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/tokenization_updated_webhook_event.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationUpdatedWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::TokenizationUpdatedWebhookEvent,
+            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
+
+      sig { returns(Lithic::Tokenization) }
+      attr_reader :tokenization
+
+      sig { params(tokenization: Lithic::Tokenization::OrHash).void }
+      attr_writer :tokenization
+
+      sig do
+        params(
+          account_token: String,
+          card_token: String,
+          created: Time,
+          tokenization: Lithic::Tokenization::OrHash,
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Account token
+        account_token:,
+        # Card token
+        card_token:,
+        # Created date
+        created:,
+        tokenization:,
+        # The type of event that occurred.
+        event_type: :"tokenization.updated"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            card_token: String,
+            created: Time,
+            event_type: Symbol,
+            tokenization: Lithic::Tokenization
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end