lithic 0.1.0.pre.alpha.56 → 0.1.0

data/rbi/lithic/models/cardholder_authentication.rbi

@@ -0,0 +1,296 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardholderAuthentication < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CardholderAuthentication, Lithic::Internal::AnyHash)
+        end
+
+      # Indicates the method used to authenticate the cardholder.
+      sig do
+        returns(
+          Lithic::CardholderAuthentication::AuthenticationMethod::TaggedSymbol
+        )
+      end
+      attr_accessor :authentication_method
+
+      # Indicates the outcome of the 3DS authentication process.
+      sig do
+        returns(
+          Lithic::CardholderAuthentication::AuthenticationResult::TaggedSymbol
+        )
+      end
+      attr_accessor :authentication_result
+
+      # Indicates which party made the 3DS authentication decision.
+      sig do
+        returns(Lithic::CardholderAuthentication::DecisionMadeBy::TaggedSymbol)
+      end
+      attr_accessor :decision_made_by
+
+      # Indicates whether chargeback liability shift applies to the transaction.
+      # Possible enum values:
+      #
+      # - `3DS_AUTHENTICATED`: The transaction was fully authenticated through a 3-D
+      #   Secure flow, chargeback liability shift applies.
+      # - `NONE`: Chargeback liability shift has not shifted to the issuer, i.e. the
+      #   merchant is liable.
+      # - `TOKEN_AUTHENTICATED`: The transaction was a tokenized payment with validated
+      #   cryptography, possibly recurring. Chargeback liability shift to the issuer
+      #   applies.
+      sig do
+        returns(Lithic::CardholderAuthentication::LiabilityShift::TaggedSymbol)
+      end
+      attr_accessor :liability_shift
+
+      # Unique identifier you can use to match a given 3DS authentication (available via
+      # the three_ds_authentication.created event webhook) and the transaction. Note
+      # that in cases where liability shift does not occur, this token is matched to the
+      # transaction on a best-effort basis.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :three_ds_authentication_token
+
+      sig do
+        params(
+          authentication_method:
+            Lithic::CardholderAuthentication::AuthenticationMethod::OrSymbol,
+          authentication_result:
+            Lithic::CardholderAuthentication::AuthenticationResult::OrSymbol,
+          decision_made_by:
+            Lithic::CardholderAuthentication::DecisionMadeBy::OrSymbol,
+          liability_shift:
+            Lithic::CardholderAuthentication::LiabilityShift::OrSymbol,
+          three_ds_authentication_token: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Indicates the method used to authenticate the cardholder.
+        authentication_method:,
+        # Indicates the outcome of the 3DS authentication process.
+        authentication_result:,
+        # Indicates which party made the 3DS authentication decision.
+        decision_made_by:,
+        # Indicates whether chargeback liability shift applies to the transaction.
+        # Possible enum values:
+        #
+        # - `3DS_AUTHENTICATED`: The transaction was fully authenticated through a 3-D
+        #   Secure flow, chargeback liability shift applies.
+        # - `NONE`: Chargeback liability shift has not shifted to the issuer, i.e. the
+        #   merchant is liable.
+        # - `TOKEN_AUTHENTICATED`: The transaction was a tokenized payment with validated
+        #   cryptography, possibly recurring. Chargeback liability shift to the issuer
+        #   applies.
+        liability_shift:,
+        # Unique identifier you can use to match a given 3DS authentication (available via
+        # the three_ds_authentication.created event webhook) and the transaction. Note
+        # that in cases where liability shift does not occur, this token is matched to the
+        # transaction on a best-effort basis.
+        three_ds_authentication_token:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            authentication_method:
+              Lithic::CardholderAuthentication::AuthenticationMethod::TaggedSymbol,
+            authentication_result:
+              Lithic::CardholderAuthentication::AuthenticationResult::TaggedSymbol,
+            decision_made_by:
+              Lithic::CardholderAuthentication::DecisionMadeBy::TaggedSymbol,
+            liability_shift:
+              Lithic::CardholderAuthentication::LiabilityShift::TaggedSymbol,
+            three_ds_authentication_token: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Indicates the method used to authenticate the cardholder.
+      module AuthenticationMethod
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::CardholderAuthentication::AuthenticationMethod
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        FRICTIONLESS =
+          T.let(
+            :FRICTIONLESS,
+            Lithic::CardholderAuthentication::AuthenticationMethod::TaggedSymbol
+          )
+        CHALLENGE =
+          T.let(
+            :CHALLENGE,
+            Lithic::CardholderAuthentication::AuthenticationMethod::TaggedSymbol
+          )
+        NONE =
+          T.let(
+            :NONE,
+            Lithic::CardholderAuthentication::AuthenticationMethod::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::CardholderAuthentication::AuthenticationMethod::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Indicates the outcome of the 3DS authentication process.
+      module AuthenticationResult
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::CardholderAuthentication::AuthenticationResult
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ATTEMPTS =
+          T.let(
+            :ATTEMPTS,
+            Lithic::CardholderAuthentication::AuthenticationResult::TaggedSymbol
+          )
+        DECLINE =
+          T.let(
+            :DECLINE,
+            Lithic::CardholderAuthentication::AuthenticationResult::TaggedSymbol
+          )
+        NONE =
+          T.let(
+            :NONE,
+            Lithic::CardholderAuthentication::AuthenticationResult::TaggedSymbol
+          )
+        SUCCESS =
+          T.let(
+            :SUCCESS,
+            Lithic::CardholderAuthentication::AuthenticationResult::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::CardholderAuthentication::AuthenticationResult::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Indicates which party made the 3DS authentication decision.
+      module DecisionMadeBy
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::CardholderAuthentication::DecisionMadeBy)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CUSTOMER_RULES =
+          T.let(
+            :CUSTOMER_RULES,
+            Lithic::CardholderAuthentication::DecisionMadeBy::TaggedSymbol
+          )
+        CUSTOMER_ENDPOINT =
+          T.let(
+            :CUSTOMER_ENDPOINT,
+            Lithic::CardholderAuthentication::DecisionMadeBy::TaggedSymbol
+          )
+        LITHIC_DEFAULT =
+          T.let(
+            :LITHIC_DEFAULT,
+            Lithic::CardholderAuthentication::DecisionMadeBy::TaggedSymbol
+          )
+        LITHIC_RULES =
+          T.let(
+            :LITHIC_RULES,
+            Lithic::CardholderAuthentication::DecisionMadeBy::TaggedSymbol
+          )
+        NETWORK =
+          T.let(
+            :NETWORK,
+            Lithic::CardholderAuthentication::DecisionMadeBy::TaggedSymbol
+          )
+        UNKNOWN =
+          T.let(
+            :UNKNOWN,
+            Lithic::CardholderAuthentication::DecisionMadeBy::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::CardholderAuthentication::DecisionMadeBy::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Indicates whether chargeback liability shift applies to the transaction.
+      # Possible enum values:
+      #
+      # - `3DS_AUTHENTICATED`: The transaction was fully authenticated through a 3-D
+      #   Secure flow, chargeback liability shift applies.
+      # - `NONE`: Chargeback liability shift has not shifted to the issuer, i.e. the
+      #   merchant is liable.
+      # - `TOKEN_AUTHENTICATED`: The transaction was a tokenized payment with validated
+      #   cryptography, possibly recurring. Chargeback liability shift to the issuer
+      #   applies.
+      module LiabilityShift
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::CardholderAuthentication::LiabilityShift)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        LIABILITY_SHIFT_3DS_AUTHENTICATED =
+          T.let(
+            :"3DS_AUTHENTICATED",
+            Lithic::CardholderAuthentication::LiabilityShift::TaggedSymbol
+          )
+        TOKEN_AUTHENTICATED =
+          T.let(
+            :TOKEN_AUTHENTICATED,
+            Lithic::CardholderAuthentication::LiabilityShift::TaggedSymbol
+          )
+        NONE =
+          T.let(
+            :NONE,
+            Lithic::CardholderAuthentication::LiabilityShift::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::CardholderAuthentication::LiabilityShift::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/device.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class Device < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Lithic::Device, Lithic::Internal::AnyHash) }
+
+      # The IMEI number of the device being provisioned. For Amex, this field contains
+      # device ID instead as IMEI is not provided
+      sig { returns(T.nilable(String)) }
+      attr_accessor :imei
+
+      # The IP address of the device initiating the request
+      sig { returns(T.nilable(String)) }
+      attr_accessor :ip_address
+
+      # Latitude and longitude where the device is located during the authorization
+      # attempt
+      sig { returns(T.nilable(String)) }
+      attr_accessor :location
+
+      sig do
+        params(
+          imei: T.nilable(String),
+          ip_address: T.nilable(String),
+          location: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The IMEI number of the device being provisioned. For Amex, this field contains
+        # device ID instead as IMEI is not provided
+        imei:,
+        # The IP address of the device initiating the request
+        ip_address:,
+        # Latitude and longitude where the device is located during the authorization
+        # attempt
+        location:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            imei: T.nilable(String),
+            ip_address: T.nilable(String),
+            location: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/digital_wallet_token_metadata.rbi

@@ -0,0 +1,290 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DigitalWalletTokenMetadata < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::DigitalWalletTokenMetadata, Lithic::Internal::AnyHash)
+        end
+
+      # Contains the information of the account responsible for the payment.
+      sig { returns(Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo) }
+      attr_reader :payment_account_info
+
+      sig do
+        params(
+          payment_account_info:
+            Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo::OrHash
+        ).void
+      end
+      attr_writer :payment_account_info
+
+      # The current status of the digital wallet token. Pending or declined.
+      sig { returns(String) }
+      attr_accessor :status
+
+      # The identifier of the Payment App instance within a device that will be
+      # provisioned with a token
+      sig { returns(T.nilable(String)) }
+      attr_accessor :payment_app_instance_id
+
+      # The party that requested the digitization
+      sig { returns(T.nilable(String)) }
+      attr_reader :token_requestor_id
+
+      sig { params(token_requestor_id: String).void }
+      attr_writer :token_requestor_id
+
+      # Human-readable name of the wallet that the token_requestor_id maps to.
+      sig do
+        returns(
+          T.nilable(
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::OrSymbol
+          )
+        )
+      end
+      attr_reader :token_requestor_name
+
+      sig do
+        params(
+          token_requestor_name:
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::OrSymbol
+        ).void
+      end
+      attr_writer :token_requestor_name
+
+      # Contains the metadata for the digital wallet being tokenized.
+      sig do
+        params(
+          payment_account_info:
+            Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo::OrHash,
+          status: String,
+          payment_app_instance_id: T.nilable(String),
+          token_requestor_id: String,
+          token_requestor_name:
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Contains the information of the account responsible for the payment.
+        payment_account_info:,
+        # The current status of the digital wallet token. Pending or declined.
+        status:,
+        # The identifier of the Payment App instance within a device that will be
+        # provisioned with a token
+        payment_app_instance_id: nil,
+        # The party that requested the digitization
+        token_requestor_id: nil,
+        # Human-readable name of the wallet that the token_requestor_id maps to.
+        token_requestor_name: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            payment_account_info:
+              Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo,
+            status: String,
+            payment_app_instance_id: T.nilable(String),
+            token_requestor_id: String,
+            token_requestor_name:
+              Lithic::DigitalWalletTokenMetadata::TokenRequestorName::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class PaymentAccountInfo < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Additional information that can be used to identify the account holder, such as
+        # name, address, etc
+        sig do
+          returns(
+            Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo::AccountHolderData
+          )
+        end
+        attr_reader :account_holder_data
+
+        sig do
+          params(
+            account_holder_data:
+              Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo::AccountHolderData::OrHash
+          ).void
+        end
+        attr_writer :account_holder_data
+
+        # Reference to the PAN that is unique per Wallet Provider
+        sig { returns(T.nilable(String)) }
+        attr_accessor :pan_unique_reference
+
+        # The unique account reference assigned to the PAN
+        sig { returns(T.nilable(String)) }
+        attr_accessor :payment_account_reference
+
+        # A unique reference assigned following the allocation of a token used to identify
+        # the token for the duration of its lifetime.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :token_unique_reference
+
+        # Contains the information of the account responsible for the payment.
+        sig do
+          params(
+            account_holder_data:
+              Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo::AccountHolderData::OrHash,
+            pan_unique_reference: T.nilable(String),
+            payment_account_reference: T.nilable(String),
+            token_unique_reference: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Additional information that can be used to identify the account holder, such as
+          # name, address, etc
+          account_holder_data:,
+          # Reference to the PAN that is unique per Wallet Provider
+          pan_unique_reference: nil,
+          # The unique account reference assigned to the PAN
+          payment_account_reference: nil,
+          # A unique reference assigned following the allocation of a token used to identify
+          # the token for the duration of its lifetime.
+          token_unique_reference: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              account_holder_data:
+                Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo::AccountHolderData,
+              pan_unique_reference: T.nilable(String),
+              payment_account_reference: T.nilable(String),
+              token_unique_reference: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class AccountHolderData < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::DigitalWalletTokenMetadata::PaymentAccountInfo::AccountHolderData,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # The phone number, may contain country code along with phone number when
+          # countryDialInCode is not present
+          sig { returns(T.nilable(String)) }
+          attr_accessor :phone_number
+
+          # Additional information that can be used to identify the account holder, such as
+          # name, address, etc
+          sig do
+            params(phone_number: T.nilable(String)).returns(T.attached_class)
+          end
+          def self.new(
+            # The phone number, may contain country code along with phone number when
+            # countryDialInCode is not present
+            phone_number: nil
+          )
+          end
+
+          sig { override.returns({ phone_number: T.nilable(String) }) }
+          def to_hash
+          end
+        end
+      end
+
+      # Human-readable name of the wallet that the token_requestor_id maps to.
+      module TokenRequestorName
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::DigitalWalletTokenMetadata::TokenRequestorName
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AMAZON_ONE =
+          T.let(
+            :AMAZON_ONE,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        ANDROID_PAY =
+          T.let(
+            :ANDROID_PAY,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        APPLE_PAY =
+          T.let(
+            :APPLE_PAY,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        FACEBOOK =
+          T.let(
+            :FACEBOOK,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        FITBIT_PAY =
+          T.let(
+            :FITBIT_PAY,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        GARMIN_PAY =
+          T.let(
+            :GARMIN_PAY,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        MICROSOFT_PAY =
+          T.let(
+            :MICROSOFT_PAY,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        NETFLIX =
+          T.let(
+            :NETFLIX,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        SAMSUNG_PAY =
+          T.let(
+            :SAMSUNG_PAY,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        UNKNOWN =
+          T.let(
+            :UNKNOWN,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+        VISA_CHECKOUT =
+          T.let(
+            :VISA_CHECKOUT,
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end