Key.h

 
#pragma once
#include <aws/payment-cryptography/PaymentCryptography_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/payment-cryptography/model/KeyAttributes.h>
#include <aws/payment-cryptography/model/KeyCheckValueAlgorithm.h>
#include <aws/payment-cryptography/model/KeyState.h>
#include <aws/payment-cryptography/model/KeyOrigin.h>
#include <aws/core/utils/DateTime.h>
#include <aws/payment-cryptography/model/DeriveKeyUsage.h>
#include <aws/payment-cryptography/model/MultiRegionKeyType.h>
#include <aws/core/utils/memory/stl/AWSMap.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;}
  private:
 
    Aws::String m_keyArn;
    bool m_keyArnHasBeenSet = false;
 
    KeyAttributes m_keyAttributes;
    bool m_keyAttributesHasBeenSet = false;
 
    Aws::String m_keyCheckValue;
    bool m_keyCheckValueHasBeenSet = false;
 
    KeyCheckValueAlgorithm m_keyCheckValueAlgorithm{KeyCheckValueAlgorithm::NOT_SET};
    bool m_keyCheckValueAlgorithmHasBeenSet = false;
 
    bool m_enabled{false};
    bool m_enabledHasBeenSet = false;
 
    bool m_exportable{false};
    bool m_exportableHasBeenSet = false;
 
    KeyState m_keyState{KeyState::NOT_SET};
    bool m_keyStateHasBeenSet = false;
 
    KeyOrigin m_keyOrigin{KeyOrigin::NOT_SET};
    bool m_keyOriginHasBeenSet = false;
 
    Aws::Utils::DateTime m_createTimestamp{};
    bool m_createTimestampHasBeenSet = false;
 
    Aws::Utils::DateTime m_usageStartTimestamp{};
    bool m_usageStartTimestampHasBeenSet = false;
 
    Aws::Utils::DateTime m_usageStopTimestamp{};
    bool m_usageStopTimestampHasBeenSet = false;
 
    Aws::Utils::DateTime m_deletePendingTimestamp{};
    bool m_deletePendingTimestampHasBeenSet = false;
 
    Aws::Utils::DateTime m_deleteTimestamp{};
    bool m_deleteTimestampHasBeenSet = false;
 
    DeriveKeyUsage m_deriveKeyUsage{DeriveKeyUsage::NOT_SET};
    bool m_deriveKeyUsageHasBeenSet = false;
 
    MultiRegionKeyType m_multiRegionKeyType{MultiRegionKeyType::NOT_SET};
    bool m_multiRegionKeyTypeHasBeenSet = false;
 
    Aws::String m_primaryRegion;
    bool m_primaryRegionHasBeenSet = false;
 
    Aws::Map<Aws::String, ReplicationStatusType> m_replicationStatus;
    bool m_replicationStatusHasBeenSet = false;
 
    bool m_usingDefaultReplicationRegions{false};
    bool m_usingDefaultReplicationRegionsHasBeenSet = false;
  };
 
} // namespace Model
} // namespace PaymentCryptography
} // namespace Aws