EncryptDataRequest.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/EncryptionDecryptionAttributes.h>
#include <aws/payment-cryptography-data/model/WrappedKey.h>
 
#include <utility>
 
namespace Aws {
namespace PaymentCryptographyData {
namespace Model {
 
class EncryptDataRequest : public PaymentCryptographyDataRequest {
 public:
  AWS_PAYMENTCRYPTOGRAPHYDATA_API EncryptDataRequest() = 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 "EncryptData"; }
 
  AWS_PAYMENTCRYPTOGRAPHYDATA_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetKeyIdentifier() const { return m_keyIdentifier; }
  inline bool KeyIdentifierHasBeenSet() const { return m_keyIdentifierHasBeenSet; }
  template <typename KeyIdentifierT = Aws::String>
  void SetKeyIdentifier(KeyIdentifierT&& value) {
    m_keyIdentifierHasBeenSet = true;
    m_keyIdentifier = std::forward<KeyIdentifierT>(value);
  }
  template <typename KeyIdentifierT = Aws::String>
  EncryptDataRequest& WithKeyIdentifier(KeyIdentifierT&& value) {
    SetKeyIdentifier(std::forward<KeyIdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPlainText() const { return m_plainText; }
  inline bool PlainTextHasBeenSet() const { return m_plainTextHasBeenSet; }
  template <typename PlainTextT = Aws::String>
  void SetPlainText(PlainTextT&& value) {
    m_plainTextHasBeenSet = true;
    m_plainText = std::forward<PlainTextT>(value);
  }
  template <typename PlainTextT = Aws::String>
  EncryptDataRequest& WithPlainText(PlainTextT&& value) {
    SetPlainText(std::forward<PlainTextT>(value));
    return *this;
  }
 
 
  inline const EncryptionDecryptionAttributes& GetEncryptionAttributes() const { return m_encryptionAttributes; }
  inline bool EncryptionAttributesHasBeenSet() const { return m_encryptionAttributesHasBeenSet; }
  template <typename EncryptionAttributesT = EncryptionDecryptionAttributes>
  void SetEncryptionAttributes(EncryptionAttributesT&& value) {
    m_encryptionAttributesHasBeenSet = true;
    m_encryptionAttributes = std::forward<EncryptionAttributesT>(value);
  }
  template <typename EncryptionAttributesT = EncryptionDecryptionAttributes>
  EncryptDataRequest& WithEncryptionAttributes(EncryptionAttributesT&& value) {
    SetEncryptionAttributes(std::forward<EncryptionAttributesT>(value));
    return *this;
  }
 
 
  inline const WrappedKey& GetWrappedKey() const { return m_wrappedKey; }
  inline bool WrappedKeyHasBeenSet() const { return m_wrappedKeyHasBeenSet; }
  template <typename WrappedKeyT = WrappedKey>
  void SetWrappedKey(WrappedKeyT&& value) {
    m_wrappedKeyHasBeenSet = true;
    m_wrappedKey = std::forward<WrappedKeyT>(value);
  }
  template <typename WrappedKeyT = WrappedKey>
  EncryptDataRequest& WithWrappedKey(WrappedKeyT&& value) {
    SetWrappedKey(std::forward<WrappedKeyT>(value));
    return *this;
  }
 private:
  Aws::String m_keyIdentifier;
 
  Aws::String m_plainText;
 
  EncryptionDecryptionAttributes m_encryptionAttributes;
 
  WrappedKey m_wrappedKey;
  bool m_keyIdentifierHasBeenSet = false;
  bool m_plainTextHasBeenSet = false;
  bool m_encryptionAttributesHasBeenSet = false;
  bool m_wrappedKeyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace PaymentCryptographyData
}  // namespace Aws