VerifyPinDataRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/payment-cryptography-data/PaymentCryptographyDataRequest.h>
#include <aws/payment-cryptography-data/PaymentCryptographyData_EXPORTS.h>
#include <aws/payment-cryptography-data/model/DukptAttributes.h>
#include <aws/payment-cryptography-data/model/PinBlockFormatForPinData.h>
#include <aws/payment-cryptography-data/model/PinVerificationAttributes.h>
#include <aws/payment-cryptography-data/model/WrappedKey.h>
 
#include <utility>
 
namespace Aws {
namespace PaymentCryptographyData {
namespace Model {
 
class VerifyPinDataRequest : public PaymentCryptographyDataRequest {
 public:
  AWS_PAYMENTCRYPTOGRAPHYDATA_API VerifyPinDataRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "VerifyPinData"; }
 
  AWS_PAYMENTCRYPTOGRAPHYDATA_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetVerificationKeyIdentifier() const { return m_verificationKeyIdentifier; }
  inline bool VerificationKeyIdentifierHasBeenSet() const { return m_verificationKeyIdentifierHasBeenSet; }
  template <typename VerificationKeyIdentifierT = Aws::String>
  void SetVerificationKeyIdentifier(VerificationKeyIdentifierT&& value) {
    m_verificationKeyIdentifierHasBeenSet = true;
    m_verificationKeyIdentifier = std::forward<VerificationKeyIdentifierT>(value);
  }
  template <typename VerificationKeyIdentifierT = Aws::String>
  VerifyPinDataRequest& WithVerificationKeyIdentifier(VerificationKeyIdentifierT&& value) {
    SetVerificationKeyIdentifier(std::forward<VerificationKeyIdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEncryptionKeyIdentifier() const { return m_encryptionKeyIdentifier; }
  inline bool EncryptionKeyIdentifierHasBeenSet() const { return m_encryptionKeyIdentifierHasBeenSet; }
  template <typename EncryptionKeyIdentifierT = Aws::String>
  void SetEncryptionKeyIdentifier(EncryptionKeyIdentifierT&& value) {
    m_encryptionKeyIdentifierHasBeenSet = true;
    m_encryptionKeyIdentifier = std::forward<EncryptionKeyIdentifierT>(value);
  }
  template <typename EncryptionKeyIdentifierT = Aws::String>
  VerifyPinDataRequest& WithEncryptionKeyIdentifier(EncryptionKeyIdentifierT&& value) {
    SetEncryptionKeyIdentifier(std::forward<EncryptionKeyIdentifierT>(value));
    return *this;
  }
 
 
  inline const PinVerificationAttributes& GetVerificationAttributes() const { return m_verificationAttributes; }
  inline bool VerificationAttributesHasBeenSet() const { return m_verificationAttributesHasBeenSet; }
  template <typename VerificationAttributesT = PinVerificationAttributes>
  void SetVerificationAttributes(VerificationAttributesT&& value) {
    m_verificationAttributesHasBeenSet = true;
    m_verificationAttributes = std::forward<VerificationAttributesT>(value);
  }
  template <typename VerificationAttributesT = PinVerificationAttributes>
  VerifyPinDataRequest& WithVerificationAttributes(VerificationAttributesT&& value) {
    SetVerificationAttributes(std::forward<VerificationAttributesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEncryptedPinBlock() const { return m_encryptedPinBlock; }
  inline bool EncryptedPinBlockHasBeenSet() const { return m_encryptedPinBlockHasBeenSet; }
  template <typename EncryptedPinBlockT = Aws::String>
  void SetEncryptedPinBlock(EncryptedPinBlockT&& value) {
    m_encryptedPinBlockHasBeenSet = true;
    m_encryptedPinBlock = std::forward<EncryptedPinBlockT>(value);
  }
  template <typename EncryptedPinBlockT = Aws::String>
  VerifyPinDataRequest& WithEncryptedPinBlock(EncryptedPinBlockT&& value) {
    SetEncryptedPinBlock(std::forward<EncryptedPinBlockT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPrimaryAccountNumber() const { return m_primaryAccountNumber; }
  inline bool PrimaryAccountNumberHasBeenSet() const { return m_primaryAccountNumberHasBeenSet; }
  template <typename PrimaryAccountNumberT = Aws::String>
  void SetPrimaryAccountNumber(PrimaryAccountNumberT&& value) {
    m_primaryAccountNumberHasBeenSet = true;
    m_primaryAccountNumber = std::forward<PrimaryAccountNumberT>(value);
  }
  template <typename PrimaryAccountNumberT = Aws::String>
  VerifyPinDataRequest& WithPrimaryAccountNumber(PrimaryAccountNumberT&& value) {
    SetPrimaryAccountNumber(std::forward<PrimaryAccountNumberT>(value));
    return *this;
  }
 
 
  inline PinBlockFormatForPinData GetPinBlockFormat() const { return m_pinBlockFormat; }
  inline bool PinBlockFormatHasBeenSet() const { return m_pinBlockFormatHasBeenSet; }
  inline void SetPinBlockFormat(PinBlockFormatForPinData value) {
    m_pinBlockFormatHasBeenSet = true;
    m_pinBlockFormat = value;
  }
  inline VerifyPinDataRequest& WithPinBlockFormat(PinBlockFormatForPinData value) {
    SetPinBlockFormat(value);
    return *this;
  }
 
 
  inline int GetPinDataLength() const { return m_pinDataLength; }
  inline bool PinDataLengthHasBeenSet() const { return m_pinDataLengthHasBeenSet; }
  inline void SetPinDataLength(int value) {
    m_pinDataLengthHasBeenSet = true;
    m_pinDataLength = value;
  }
  inline VerifyPinDataRequest& WithPinDataLength(int value) {
    SetPinDataLength(value);
    return *this;
  }
 
 
  inline const DukptAttributes& GetDukptAttributes() const { return m_dukptAttributes; }
  inline bool DukptAttributesHasBeenSet() const { return m_dukptAttributesHasBeenSet; }
  template <typename DukptAttributesT = DukptAttributes>
  void SetDukptAttributes(DukptAttributesT&& value) {
    m_dukptAttributesHasBeenSet = true;
    m_dukptAttributes = std::forward<DukptAttributesT>(value);
  }
  template <typename DukptAttributesT = DukptAttributes>
  VerifyPinDataRequest& WithDukptAttributes(DukptAttributesT&& value) {
    SetDukptAttributes(std::forward<DukptAttributesT>(value));
    return *this;
  }
 
 
  inline const WrappedKey& GetEncryptionWrappedKey() const { return m_encryptionWrappedKey; }
  inline bool EncryptionWrappedKeyHasBeenSet() const { return m_encryptionWrappedKeyHasBeenSet; }
  template <typename EncryptionWrappedKeyT = WrappedKey>
  void SetEncryptionWrappedKey(EncryptionWrappedKeyT&& value) {
    m_encryptionWrappedKeyHasBeenSet = true;
    m_encryptionWrappedKey = std::forward<EncryptionWrappedKeyT>(value);
  }
  template <typename EncryptionWrappedKeyT = WrappedKey>
  VerifyPinDataRequest& WithEncryptionWrappedKey(EncryptionWrappedKeyT&& value) {
    SetEncryptionWrappedKey(std::forward<EncryptionWrappedKeyT>(value));
    return *this;
  }
 private:
  Aws::String m_verificationKeyIdentifier;
 
  Aws::String m_encryptionKeyIdentifier;
 
  PinVerificationAttributes m_verificationAttributes;
 
  Aws::String m_encryptedPinBlock;
 
  Aws::String m_primaryAccountNumber;
 
  PinBlockFormatForPinData m_pinBlockFormat{PinBlockFormatForPinData::NOT_SET};
 
  int m_pinDataLength{0};
 
  DukptAttributes m_dukptAttributes;
 
  WrappedKey m_encryptionWrappedKey;
  bool m_verificationKeyIdentifierHasBeenSet = false;
  bool m_encryptionKeyIdentifierHasBeenSet = false;
  bool m_verificationAttributesHasBeenSet = false;
  bool m_encryptedPinBlockHasBeenSet = false;
  bool m_primaryAccountNumberHasBeenSet = false;
  bool m_pinBlockFormatHasBeenSet = false;
  bool m_pinDataLengthHasBeenSet = false;
  bool m_dukptAttributesHasBeenSet = false;
  bool m_encryptionWrappedKeyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace PaymentCryptographyData
}  // namespace Aws