Key.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/payment-cryptography/PaymentCryptography_EXPORTS.h>
#include <aws/payment-cryptography/model/DeriveKeyUsage.h>
#include <aws/payment-cryptography/model/KeyAttributes.h>
#include <aws/payment-cryptography/model/KeyCheckValueAlgorithm.h>
#include <aws/payment-cryptography/model/KeyOrigin.h>
#include <aws/payment-cryptography/model/KeyState.h>
#include <aws/payment-cryptography/model/MpaStatus.h>
#include <aws/payment-cryptography/model/MultiRegionKeyType.h>
#include <aws/payment-cryptography/model/ReplicationStatusType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace PaymentCryptography {
namespace Model {
 
class Key {
 public:
  AWS_PAYMENTCRYPTOGRAPHY_API Key() = default;
  AWS_PAYMENTCRYPTOGRAPHY_API Key(Aws::Utils::Json::JsonView jsonValue);
  AWS_PAYMENTCRYPTOGRAPHY_API Key& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_PAYMENTCRYPTOGRAPHY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetKeyArn() const { return m_keyArn; }
  inline bool KeyArnHasBeenSet() const { return m_keyArnHasBeenSet; }
  template <typename KeyArnT = Aws::String>
  void SetKeyArn(KeyArnT&& value) {
    m_keyArnHasBeenSet = true;
    m_keyArn = std::forward<KeyArnT>(value);
  }
  template <typename KeyArnT = Aws::String>
  Key& WithKeyArn(KeyArnT&& value) {
    SetKeyArn(std::forward<KeyArnT>(value));
    return *this;
  }
 
 
  inline const KeyAttributes& GetKeyAttributes() const { return m_keyAttributes; }
  inline bool KeyAttributesHasBeenSet() const { return m_keyAttributesHasBeenSet; }
  template <typename KeyAttributesT = KeyAttributes>
  void SetKeyAttributes(KeyAttributesT&& value) {
    m_keyAttributesHasBeenSet = true;
    m_keyAttributes = std::forward<KeyAttributesT>(value);
  }
  template <typename KeyAttributesT = KeyAttributes>
  Key& WithKeyAttributes(KeyAttributesT&& value) {
    SetKeyAttributes(std::forward<KeyAttributesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKeyCheckValue() const { return m_keyCheckValue; }
  inline bool KeyCheckValueHasBeenSet() const { return m_keyCheckValueHasBeenSet; }
  template <typename KeyCheckValueT = Aws::String>
  void SetKeyCheckValue(KeyCheckValueT&& value) {
    m_keyCheckValueHasBeenSet = true;
    m_keyCheckValue = std::forward<KeyCheckValueT>(value);
  }
  template <typename KeyCheckValueT = Aws::String>
  Key& WithKeyCheckValue(KeyCheckValueT&& value) {
    SetKeyCheckValue(std::forward<KeyCheckValueT>(value));
    return *this;
  }
 
 
  inline KeyCheckValueAlgorithm GetKeyCheckValueAlgorithm() const { return m_keyCheckValueAlgorithm; }
  inline bool KeyCheckValueAlgorithmHasBeenSet() const { return m_keyCheckValueAlgorithmHasBeenSet; }
  inline void SetKeyCheckValueAlgorithm(KeyCheckValueAlgorithm value) {
    m_keyCheckValueAlgorithmHasBeenSet = true;
    m_keyCheckValueAlgorithm = value;
  }
  inline Key& WithKeyCheckValueAlgorithm(KeyCheckValueAlgorithm value) {
    SetKeyCheckValueAlgorithm(value);
    return *this;
  }
 
 
  inline bool GetEnabled() const { return m_enabled; }
  inline bool EnabledHasBeenSet() const { return m_enabledHasBeenSet; }
  inline void SetEnabled(bool value) {
    m_enabledHasBeenSet = true;
    m_enabled = value;
  }
  inline Key& WithEnabled(bool value) {
    SetEnabled(value);
    return *this;
  }
 
 
  inline bool GetExportable() const { return m_exportable; }
  inline bool ExportableHasBeenSet() const { return m_exportableHasBeenSet; }
  inline void SetExportable(bool value) {
    m_exportableHasBeenSet = true;
    m_exportable = value;
  }
  inline Key& WithExportable(bool value) {
    SetExportable(value);
    return *this;
  }
 
 
  inline KeyState GetKeyState() const { return m_keyState; }
  inline bool KeyStateHasBeenSet() const { return m_keyStateHasBeenSet; }
  inline void SetKeyState(KeyState value) {
    m_keyStateHasBeenSet = true;
    m_keyState = value;
  }
  inline Key& WithKeyState(KeyState value) {
    SetKeyState(value);
    return *this;
  }
 
 
  inline KeyOrigin GetKeyOrigin() const { return m_keyOrigin; }
  inline bool KeyOriginHasBeenSet() const { return m_keyOriginHasBeenSet; }
  inline void SetKeyOrigin(KeyOrigin value) {
    m_keyOriginHasBeenSet = true;
    m_keyOrigin = value;
  }
  inline Key& WithKeyOrigin(KeyOrigin value) {
    SetKeyOrigin(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreateTimestamp() const { return m_createTimestamp; }
  inline bool CreateTimestampHasBeenSet() const { return m_createTimestampHasBeenSet; }
  template <typename CreateTimestampT = Aws::Utils::DateTime>
  void SetCreateTimestamp(CreateTimestampT&& value) {
    m_createTimestampHasBeenSet = true;
    m_createTimestamp = std::forward<CreateTimestampT>(value);
  }
  template <typename CreateTimestampT = Aws::Utils::DateTime>
  Key& WithCreateTimestamp(CreateTimestampT&& value) {
    SetCreateTimestamp(std::forward<CreateTimestampT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetUsageStartTimestamp() const { return m_usageStartTimestamp; }
  inline bool UsageStartTimestampHasBeenSet() const { return m_usageStartTimestampHasBeenSet; }
  template <typename UsageStartTimestampT = Aws::Utils::DateTime>
  void SetUsageStartTimestamp(UsageStartTimestampT&& value) {
    m_usageStartTimestampHasBeenSet = true;
    m_usageStartTimestamp = std::forward<UsageStartTimestampT>(value);
  }
  template <typename UsageStartTimestampT = Aws::Utils::DateTime>
  Key& WithUsageStartTimestamp(UsageStartTimestampT&& value) {
    SetUsageStartTimestamp(std::forward<UsageStartTimestampT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetUsageStopTimestamp() const { return m_usageStopTimestamp; }
  inline bool UsageStopTimestampHasBeenSet() const { return m_usageStopTimestampHasBeenSet; }
  template <typename UsageStopTimestampT = Aws::Utils::DateTime>
  void SetUsageStopTimestamp(UsageStopTimestampT&& value) {
    m_usageStopTimestampHasBeenSet = true;
    m_usageStopTimestamp = std::forward<UsageStopTimestampT>(value);
  }
  template <typename UsageStopTimestampT = Aws::Utils::DateTime>
  Key& WithUsageStopTimestamp(UsageStopTimestampT&& value) {
    SetUsageStopTimestamp(std::forward<UsageStopTimestampT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetDeletePendingTimestamp() const { return m_deletePendingTimestamp; }
  inline bool DeletePendingTimestampHasBeenSet() const { return m_deletePendingTimestampHasBeenSet; }
  template <typename DeletePendingTimestampT = Aws::Utils::DateTime>
  void SetDeletePendingTimestamp(DeletePendingTimestampT&& value) {
    m_deletePendingTimestampHasBeenSet = true;
    m_deletePendingTimestamp = std::forward<DeletePendingTimestampT>(value);
  }
  template <typename DeletePendingTimestampT = Aws::Utils::DateTime>
  Key& WithDeletePendingTimestamp(DeletePendingTimestampT&& value) {
    SetDeletePendingTimestamp(std::forward<DeletePendingTimestampT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetDeleteTimestamp() const { return m_deleteTimestamp; }
  inline bool DeleteTimestampHasBeenSet() const { return m_deleteTimestampHasBeenSet; }
  template <typename DeleteTimestampT = Aws::Utils::DateTime>
  void SetDeleteTimestamp(DeleteTimestampT&& value) {
    m_deleteTimestampHasBeenSet = true;
    m_deleteTimestamp = std::forward<DeleteTimestampT>(value);
  }
  template <typename DeleteTimestampT = Aws::Utils::DateTime>
  Key& WithDeleteTimestamp(DeleteTimestampT&& value) {
    SetDeleteTimestamp(std::forward<DeleteTimestampT>(value));
    return *this;
  }
 
 
  inline DeriveKeyUsage GetDeriveKeyUsage() const { return m_deriveKeyUsage; }
  inline bool DeriveKeyUsageHasBeenSet() const { return m_deriveKeyUsageHasBeenSet; }
  inline void SetDeriveKeyUsage(DeriveKeyUsage value) {
    m_deriveKeyUsageHasBeenSet = true;
    m_deriveKeyUsage = value;
  }
  inline Key& WithDeriveKeyUsage(DeriveKeyUsage value) {
    SetDeriveKeyUsage(value);
    return *this;
  }
 
 
  inline MultiRegionKeyType GetMultiRegionKeyType() const { return m_multiRegionKeyType; }
  inline bool MultiRegionKeyTypeHasBeenSet() const { return m_multiRegionKeyTypeHasBeenSet; }
  inline void SetMultiRegionKeyType(MultiRegionKeyType value) {
    m_multiRegionKeyTypeHasBeenSet = true;
    m_multiRegionKeyType = value;
  }
  inline Key& WithMultiRegionKeyType(MultiRegionKeyType value) {
    SetMultiRegionKeyType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetPrimaryRegion() const { return m_primaryRegion; }
  inline bool PrimaryRegionHasBeenSet() const { return m_primaryRegionHasBeenSet; }
  template <typename PrimaryRegionT = Aws::String>
  void SetPrimaryRegion(PrimaryRegionT&& value) {
    m_primaryRegionHasBeenSet = true;
    m_primaryRegion = std::forward<PrimaryRegionT>(value);
  }
  template <typename PrimaryRegionT = Aws::String>
  Key& WithPrimaryRegion(PrimaryRegionT&& value) {
    SetPrimaryRegion(std::forward<PrimaryRegionT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, ReplicationStatusType>& GetReplicationStatus() const { return m_replicationStatus; }
  inline bool ReplicationStatusHasBeenSet() const { return m_replicationStatusHasBeenSet; }
  template <typename ReplicationStatusT = Aws::Map<Aws::String, ReplicationStatusType>>
  void SetReplicationStatus(ReplicationStatusT&& value) {
    m_replicationStatusHasBeenSet = true;
    m_replicationStatus = std::forward<ReplicationStatusT>(value);
  }
  template <typename ReplicationStatusT = Aws::Map<Aws::String, ReplicationStatusType>>
  Key& WithReplicationStatus(ReplicationStatusT&& value) {
    SetReplicationStatus(std::forward<ReplicationStatusT>(value));
    return *this;
  }
  template <typename ReplicationStatusKeyT = Aws::String, typename ReplicationStatusValueT = ReplicationStatusType>
  Key& AddReplicationStatus(ReplicationStatusKeyT&& key, ReplicationStatusValueT&& value) {
    m_replicationStatusHasBeenSet = true;
    m_replicationStatus.emplace(std::forward<ReplicationStatusKeyT>(key), std::forward<ReplicationStatusValueT>(value));
    return *this;
  }
 
 
  inline bool GetUsingDefaultReplicationRegions() const { return m_usingDefaultReplicationRegions; }
  inline bool UsingDefaultReplicationRegionsHasBeenSet() const { return m_usingDefaultReplicationRegionsHasBeenSet; }
  inline void SetUsingDefaultReplicationRegions(bool value) {
    m_usingDefaultReplicationRegionsHasBeenSet = true;
    m_usingDefaultReplicationRegions = value;
  }
  inline Key& WithUsingDefaultReplicationRegions(bool value) {
    SetUsingDefaultReplicationRegions(value);
    return *this;
  }
 
 
  inline const MpaStatus& GetMpaStatus() const { return m_mpaStatus; }
  inline bool MpaStatusHasBeenSet() const { return m_mpaStatusHasBeenSet; }
  template <typename MpaStatusT = MpaStatus>
  void SetMpaStatus(MpaStatusT&& value) {
    m_mpaStatusHasBeenSet = true;
    m_mpaStatus = std::forward<MpaStatusT>(value);
  }
  template <typename MpaStatusT = MpaStatus>
  Key& WithMpaStatus(MpaStatusT&& value) {
    SetMpaStatus(std::forward<MpaStatusT>(value));
    return *this;
  }
 private:
  Aws::String m_keyArn;
 
  KeyAttributes m_keyAttributes;
 
  Aws::String m_keyCheckValue;
 
  KeyCheckValueAlgorithm m_keyCheckValueAlgorithm{KeyCheckValueAlgorithm::NOT_SET};
 
  bool m_enabled{false};
 
  bool m_exportable{false};
 
  KeyState m_keyState{KeyState::NOT_SET};
 
  KeyOrigin m_keyOrigin{KeyOrigin::NOT_SET};
 
  Aws::Utils::DateTime m_createTimestamp{};
 
  Aws::Utils::DateTime m_usageStartTimestamp{};
 
  Aws::Utils::DateTime m_usageStopTimestamp{};
 
  Aws::Utils::DateTime m_deletePendingTimestamp{};
 
  Aws::Utils::DateTime m_deleteTimestamp{};
 
  DeriveKeyUsage m_deriveKeyUsage{DeriveKeyUsage::NOT_SET};
 
  MultiRegionKeyType m_multiRegionKeyType{MultiRegionKeyType::NOT_SET};
 
  Aws::String m_primaryRegion;
 
  Aws::Map<Aws::String, ReplicationStatusType> m_replicationStatus;
 
  bool m_usingDefaultReplicationRegions{false};
 
  MpaStatus m_mpaStatus;
  bool m_keyArnHasBeenSet = false;
  bool m_keyAttributesHasBeenSet = false;
  bool m_keyCheckValueHasBeenSet = false;
  bool m_keyCheckValueAlgorithmHasBeenSet = false;
  bool m_enabledHasBeenSet = false;
  bool m_exportableHasBeenSet = false;
  bool m_keyStateHasBeenSet = false;
  bool m_keyOriginHasBeenSet = false;
  bool m_createTimestampHasBeenSet = false;
  bool m_usageStartTimestampHasBeenSet = false;
  bool m_usageStopTimestampHasBeenSet = false;
  bool m_deletePendingTimestampHasBeenSet = false;
  bool m_deleteTimestampHasBeenSet = false;
  bool m_deriveKeyUsageHasBeenSet = false;
  bool m_multiRegionKeyTypeHasBeenSet = false;
  bool m_primaryRegionHasBeenSet = false;
  bool m_replicationStatusHasBeenSet = false;
  bool m_usingDefaultReplicationRegionsHasBeenSet = false;
  bool m_mpaStatusHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace PaymentCryptography
}  // namespace Aws