KeyMetadata.h

 
#pragma once
#include <aws/kms/KMS_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/DateTime.h>
#include <aws/kms/model/KeyUsageType.h>
#include <aws/kms/model/KeyState.h>
#include <aws/kms/model/OriginType.h>
#include <aws/kms/model/ExpirationModelType.h>
#include <aws/kms/model/KeyManagerType.h>
#include <aws/kms/model/KeySpec.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/kms/model/MultiRegionConfiguration.h>
#include <aws/kms/model/XksKeyConfigurationType.h>
#include <aws/kms/model/EncryptionAlgorithmSpec.h>
#include <aws/kms/model/SigningAlgorithmSpec.h>
#include <aws/kms/model/KeyAgreementAlgorithmSpec.h>
#include <aws/kms/model/MacAlgorithmSpec.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace KMS
{
namespace Model
{
 
  class KeyMetadata
  {
  public:
    AWS_KMS_API KeyMetadata() = default;
    AWS_KMS_API KeyMetadata(Aws::Utils::Json::JsonView jsonValue);
    AWS_KMS_API KeyMetadata& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_KMS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetAWSAccountId() const { return m_aWSAccountId; }
    inline bool AWSAccountIdHasBeenSet() const { return m_aWSAccountIdHasBeenSet; }
    template<typename AWSAccountIdT = Aws::String>
    void SetAWSAccountId(AWSAccountIdT&& value) { m_aWSAccountIdHasBeenSet = true; m_aWSAccountId = std::forward<AWSAccountIdT>(value); }
    template<typename AWSAccountIdT = Aws::String>
    KeyMetadata& WithAWSAccountId(AWSAccountIdT&& value) { SetAWSAccountId(std::forward<AWSAccountIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetKeyId() const { return m_keyId; }
    inline bool KeyIdHasBeenSet() const { return m_keyIdHasBeenSet; }
    template<typename KeyIdT = Aws::String>
    void SetKeyId(KeyIdT&& value) { m_keyIdHasBeenSet = true; m_keyId = std::forward<KeyIdT>(value); }
    template<typename KeyIdT = Aws::String>
    KeyMetadata& WithKeyId(KeyIdT&& value) { SetKeyId(std::forward<KeyIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetArn() const { return m_arn; }
    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
    template<typename ArnT = Aws::String>
    void SetArn(ArnT&& value) { m_arnHasBeenSet = true; m_arn = std::forward<ArnT>(value); }
    template<typename ArnT = Aws::String>
    KeyMetadata& WithArn(ArnT&& value) { SetArn(std::forward<ArnT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetCreationDate() const { return m_creationDate; }
    inline bool CreationDateHasBeenSet() const { return m_creationDateHasBeenSet; }
    template<typename CreationDateT = Aws::Utils::DateTime>
    void SetCreationDate(CreationDateT&& value) { m_creationDateHasBeenSet = true; m_creationDate = std::forward<CreationDateT>(value); }
    template<typename CreationDateT = Aws::Utils::DateTime>
    KeyMetadata& WithCreationDate(CreationDateT&& value) { SetCreationDate(std::forward<CreationDateT>(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 KeyMetadata& WithEnabled(bool value) { SetEnabled(value); return *this;}
 
 
    inline const Aws::String& GetDescription() const { return m_description; }
    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
    template<typename DescriptionT = Aws::String>
    void SetDescription(DescriptionT&& value) { m_descriptionHasBeenSet = true; m_description = std::forward<DescriptionT>(value); }
    template<typename DescriptionT = Aws::String>
    KeyMetadata& WithDescription(DescriptionT&& value) { SetDescription(std::forward<DescriptionT>(value)); return *this;}
 
 
    inline KeyUsageType GetKeyUsage() const { return m_keyUsage; }
    inline bool KeyUsageHasBeenSet() const { return m_keyUsageHasBeenSet; }
    inline void SetKeyUsage(KeyUsageType value) { m_keyUsageHasBeenSet = true; m_keyUsage = value; }
    inline KeyMetadata& WithKeyUsage(KeyUsageType value) { SetKeyUsage(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 KeyMetadata& WithKeyState(KeyState value) { SetKeyState(value); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetDeletionDate() const { return m_deletionDate; }
    inline bool DeletionDateHasBeenSet() const { return m_deletionDateHasBeenSet; }
    template<typename DeletionDateT = Aws::Utils::DateTime>
    void SetDeletionDate(DeletionDateT&& value) { m_deletionDateHasBeenSet = true; m_deletionDate = std::forward<DeletionDateT>(value); }
    template<typename DeletionDateT = Aws::Utils::DateTime>
    KeyMetadata& WithDeletionDate(DeletionDateT&& value) { SetDeletionDate(std::forward<DeletionDateT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetValidTo() const { return m_validTo; }
    inline bool ValidToHasBeenSet() const { return m_validToHasBeenSet; }
    template<typename ValidToT = Aws::Utils::DateTime>
    void SetValidTo(ValidToT&& value) { m_validToHasBeenSet = true; m_validTo = std::forward<ValidToT>(value); }
    template<typename ValidToT = Aws::Utils::DateTime>
    KeyMetadata& WithValidTo(ValidToT&& value) { SetValidTo(std::forward<ValidToT>(value)); return *this;}
 
 
    inline OriginType GetOrigin() const { return m_origin; }
    inline bool OriginHasBeenSet() const { return m_originHasBeenSet; }
    inline void SetOrigin(OriginType value) { m_originHasBeenSet = true; m_origin = value; }
    inline KeyMetadata& WithOrigin(OriginType value) { SetOrigin(value); return *this;}
 
 
    inline const Aws::String& GetCustomKeyStoreId() const { return m_customKeyStoreId; }
    inline bool CustomKeyStoreIdHasBeenSet() const { return m_customKeyStoreIdHasBeenSet; }
    template<typename CustomKeyStoreIdT = Aws::String>
    void SetCustomKeyStoreId(CustomKeyStoreIdT&& value) { m_customKeyStoreIdHasBeenSet = true; m_customKeyStoreId = std::forward<CustomKeyStoreIdT>(value); }
    template<typename CustomKeyStoreIdT = Aws::String>
    KeyMetadata& WithCustomKeyStoreId(CustomKeyStoreIdT&& value) { SetCustomKeyStoreId(std::forward<CustomKeyStoreIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetCloudHsmClusterId() const { return m_cloudHsmClusterId; }
    inline bool CloudHsmClusterIdHasBeenSet() const { return m_cloudHsmClusterIdHasBeenSet; }
    template<typename CloudHsmClusterIdT = Aws::String>
    void SetCloudHsmClusterId(CloudHsmClusterIdT&& value) { m_cloudHsmClusterIdHasBeenSet = true; m_cloudHsmClusterId = std::forward<CloudHsmClusterIdT>(value); }
    template<typename CloudHsmClusterIdT = Aws::String>
    KeyMetadata& WithCloudHsmClusterId(CloudHsmClusterIdT&& value) { SetCloudHsmClusterId(std::forward<CloudHsmClusterIdT>(value)); return *this;}
 
 
    inline ExpirationModelType GetExpirationModel() const { return m_expirationModel; }
    inline bool ExpirationModelHasBeenSet() const { return m_expirationModelHasBeenSet; }
    inline void SetExpirationModel(ExpirationModelType value) { m_expirationModelHasBeenSet = true; m_expirationModel = value; }
    inline KeyMetadata& WithExpirationModel(ExpirationModelType value) { SetExpirationModel(value); return *this;}
 
 
    inline KeyManagerType GetKeyManager() const { return m_keyManager; }
    inline bool KeyManagerHasBeenSet() const { return m_keyManagerHasBeenSet; }
    inline void SetKeyManager(KeyManagerType value) { m_keyManagerHasBeenSet = true; m_keyManager = value; }
    inline KeyMetadata& WithKeyManager(KeyManagerType value) { SetKeyManager(value); return *this;}
 
 
    inline KeySpec GetKeySpec() const { return m_keySpec; }
    inline bool KeySpecHasBeenSet() const { return m_keySpecHasBeenSet; }
    inline void SetKeySpec(KeySpec value) { m_keySpecHasBeenSet = true; m_keySpec = value; }
    inline KeyMetadata& WithKeySpec(KeySpec value) { SetKeySpec(value); return *this;}
 
 
    inline const Aws::Vector<EncryptionAlgorithmSpec>& GetEncryptionAlgorithms() const { return m_encryptionAlgorithms; }
    inline bool EncryptionAlgorithmsHasBeenSet() const { return m_encryptionAlgorithmsHasBeenSet; }
    template<typename EncryptionAlgorithmsT = Aws::Vector<EncryptionAlgorithmSpec>>
    void SetEncryptionAlgorithms(EncryptionAlgorithmsT&& value) { m_encryptionAlgorithmsHasBeenSet = true; m_encryptionAlgorithms = std::forward<EncryptionAlgorithmsT>(value); }
    template<typename EncryptionAlgorithmsT = Aws::Vector<EncryptionAlgorithmSpec>>
    KeyMetadata& WithEncryptionAlgorithms(EncryptionAlgorithmsT&& value) { SetEncryptionAlgorithms(std::forward<EncryptionAlgorithmsT>(value)); return *this;}
    inline KeyMetadata& AddEncryptionAlgorithms(EncryptionAlgorithmSpec value) { m_encryptionAlgorithmsHasBeenSet = true; m_encryptionAlgorithms.push_back(value); return *this; }
 
 
    inline const Aws::Vector<SigningAlgorithmSpec>& GetSigningAlgorithms() const { return m_signingAlgorithms; }
    inline bool SigningAlgorithmsHasBeenSet() const { return m_signingAlgorithmsHasBeenSet; }
    template<typename SigningAlgorithmsT = Aws::Vector<SigningAlgorithmSpec>>
    void SetSigningAlgorithms(SigningAlgorithmsT&& value) { m_signingAlgorithmsHasBeenSet = true; m_signingAlgorithms = std::forward<SigningAlgorithmsT>(value); }
    template<typename SigningAlgorithmsT = Aws::Vector<SigningAlgorithmSpec>>
    KeyMetadata& WithSigningAlgorithms(SigningAlgorithmsT&& value) { SetSigningAlgorithms(std::forward<SigningAlgorithmsT>(value)); return *this;}
    inline KeyMetadata& AddSigningAlgorithms(SigningAlgorithmSpec value) { m_signingAlgorithmsHasBeenSet = true; m_signingAlgorithms.push_back(value); return *this; }
 
 
    inline const Aws::Vector<KeyAgreementAlgorithmSpec>& GetKeyAgreementAlgorithms() const { return m_keyAgreementAlgorithms; }
    inline bool KeyAgreementAlgorithmsHasBeenSet() const { return m_keyAgreementAlgorithmsHasBeenSet; }
    template<typename KeyAgreementAlgorithmsT = Aws::Vector<KeyAgreementAlgorithmSpec>>
    void SetKeyAgreementAlgorithms(KeyAgreementAlgorithmsT&& value) { m_keyAgreementAlgorithmsHasBeenSet = true; m_keyAgreementAlgorithms = std::forward<KeyAgreementAlgorithmsT>(value); }
    template<typename KeyAgreementAlgorithmsT = Aws::Vector<KeyAgreementAlgorithmSpec>>
    KeyMetadata& WithKeyAgreementAlgorithms(KeyAgreementAlgorithmsT&& value) { SetKeyAgreementAlgorithms(std::forward<KeyAgreementAlgorithmsT>(value)); return *this;}
    inline KeyMetadata& AddKeyAgreementAlgorithms(KeyAgreementAlgorithmSpec value) { m_keyAgreementAlgorithmsHasBeenSet = true; m_keyAgreementAlgorithms.push_back(value); return *this; }
 
 
    inline bool GetMultiRegion() const { return m_multiRegion; }
    inline bool MultiRegionHasBeenSet() const { return m_multiRegionHasBeenSet; }
    inline void SetMultiRegion(bool value) { m_multiRegionHasBeenSet = true; m_multiRegion = value; }
    inline KeyMetadata& WithMultiRegion(bool value) { SetMultiRegion(value); return *this;}
 
 
    inline const MultiRegionConfiguration& GetMultiRegionConfiguration() const { return m_multiRegionConfiguration; }
    inline bool MultiRegionConfigurationHasBeenSet() const { return m_multiRegionConfigurationHasBeenSet; }
    template<typename MultiRegionConfigurationT = MultiRegionConfiguration>
    void SetMultiRegionConfiguration(MultiRegionConfigurationT&& value) { m_multiRegionConfigurationHasBeenSet = true; m_multiRegionConfiguration = std::forward<MultiRegionConfigurationT>(value); }
    template<typename MultiRegionConfigurationT = MultiRegionConfiguration>
    KeyMetadata& WithMultiRegionConfiguration(MultiRegionConfigurationT&& value) { SetMultiRegionConfiguration(std::forward<MultiRegionConfigurationT>(value)); return *this;}
 
 
    inline int GetPendingDeletionWindowInDays() const { return m_pendingDeletionWindowInDays; }
    inline bool PendingDeletionWindowInDaysHasBeenSet() const { return m_pendingDeletionWindowInDaysHasBeenSet; }
    inline void SetPendingDeletionWindowInDays(int value) { m_pendingDeletionWindowInDaysHasBeenSet = true; m_pendingDeletionWindowInDays = value; }
    inline KeyMetadata& WithPendingDeletionWindowInDays(int value) { SetPendingDeletionWindowInDays(value); return *this;}
 
 
    inline const Aws::Vector<MacAlgorithmSpec>& GetMacAlgorithms() const { return m_macAlgorithms; }
    inline bool MacAlgorithmsHasBeenSet() const { return m_macAlgorithmsHasBeenSet; }
    template<typename MacAlgorithmsT = Aws::Vector<MacAlgorithmSpec>>
    void SetMacAlgorithms(MacAlgorithmsT&& value) { m_macAlgorithmsHasBeenSet = true; m_macAlgorithms = std::forward<MacAlgorithmsT>(value); }
    template<typename MacAlgorithmsT = Aws::Vector<MacAlgorithmSpec>>
    KeyMetadata& WithMacAlgorithms(MacAlgorithmsT&& value) { SetMacAlgorithms(std::forward<MacAlgorithmsT>(value)); return *this;}
    inline KeyMetadata& AddMacAlgorithms(MacAlgorithmSpec value) { m_macAlgorithmsHasBeenSet = true; m_macAlgorithms.push_back(value); return *this; }
 
 
    inline const XksKeyConfigurationType& GetXksKeyConfiguration() const { return m_xksKeyConfiguration; }
    inline bool XksKeyConfigurationHasBeenSet() const { return m_xksKeyConfigurationHasBeenSet; }
    template<typename XksKeyConfigurationT = XksKeyConfigurationType>
    void SetXksKeyConfiguration(XksKeyConfigurationT&& value) { m_xksKeyConfigurationHasBeenSet = true; m_xksKeyConfiguration = std::forward<XksKeyConfigurationT>(value); }
    template<typename XksKeyConfigurationT = XksKeyConfigurationType>
    KeyMetadata& WithXksKeyConfiguration(XksKeyConfigurationT&& value) { SetXksKeyConfiguration(std::forward<XksKeyConfigurationT>(value)); return *this;}
 
 
    inline const Aws::String& GetCurrentKeyMaterialId() const { return m_currentKeyMaterialId; }
    inline bool CurrentKeyMaterialIdHasBeenSet() const { return m_currentKeyMaterialIdHasBeenSet; }
    template<typename CurrentKeyMaterialIdT = Aws::String>
    void SetCurrentKeyMaterialId(CurrentKeyMaterialIdT&& value) { m_currentKeyMaterialIdHasBeenSet = true; m_currentKeyMaterialId = std::forward<CurrentKeyMaterialIdT>(value); }
    template<typename CurrentKeyMaterialIdT = Aws::String>
    KeyMetadata& WithCurrentKeyMaterialId(CurrentKeyMaterialIdT&& value) { SetCurrentKeyMaterialId(std::forward<CurrentKeyMaterialIdT>(value)); return *this;}
  private:
 
    Aws::String m_aWSAccountId;
    bool m_aWSAccountIdHasBeenSet = false;
 
    Aws::String m_keyId;
    bool m_keyIdHasBeenSet = false;
 
    Aws::String m_arn;
    bool m_arnHasBeenSet = false;
 
    Aws::Utils::DateTime m_creationDate{};
    bool m_creationDateHasBeenSet = false;
 
    bool m_enabled{false};
    bool m_enabledHasBeenSet = false;
 
    Aws::String m_description;
    bool m_descriptionHasBeenSet = false;
 
    KeyUsageType m_keyUsage{KeyUsageType::NOT_SET};
    bool m_keyUsageHasBeenSet = false;
 
    KeyState m_keyState{KeyState::NOT_SET};
    bool m_keyStateHasBeenSet = false;
 
    Aws::Utils::DateTime m_deletionDate{};
    bool m_deletionDateHasBeenSet = false;
 
    Aws::Utils::DateTime m_validTo{};
    bool m_validToHasBeenSet = false;
 
    OriginType m_origin{OriginType::NOT_SET};
    bool m_originHasBeenSet = false;
 
    Aws::String m_customKeyStoreId;
    bool m_customKeyStoreIdHasBeenSet = false;
 
    Aws::String m_cloudHsmClusterId;
    bool m_cloudHsmClusterIdHasBeenSet = false;
 
    ExpirationModelType m_expirationModel{ExpirationModelType::NOT_SET};
    bool m_expirationModelHasBeenSet = false;
 
    KeyManagerType m_keyManager{KeyManagerType::NOT_SET};
    bool m_keyManagerHasBeenSet = false;
 
    KeySpec m_keySpec{KeySpec::NOT_SET};
    bool m_keySpecHasBeenSet = false;
 
    Aws::Vector<EncryptionAlgorithmSpec> m_encryptionAlgorithms;
    bool m_encryptionAlgorithmsHasBeenSet = false;
 
    Aws::Vector<SigningAlgorithmSpec> m_signingAlgorithms;
    bool m_signingAlgorithmsHasBeenSet = false;
 
    Aws::Vector<KeyAgreementAlgorithmSpec> m_keyAgreementAlgorithms;
    bool m_keyAgreementAlgorithmsHasBeenSet = false;
 
    bool m_multiRegion{false};
    bool m_multiRegionHasBeenSet = false;
 
    MultiRegionConfiguration m_multiRegionConfiguration;
    bool m_multiRegionConfigurationHasBeenSet = false;
 
    int m_pendingDeletionWindowInDays{0};
    bool m_pendingDeletionWindowInDaysHasBeenSet = false;
 
    Aws::Vector<MacAlgorithmSpec> m_macAlgorithms;
    bool m_macAlgorithmsHasBeenSet = false;
 
    XksKeyConfigurationType m_xksKeyConfiguration;
    bool m_xksKeyConfigurationHasBeenSet = false;
 
    Aws::String m_currentKeyMaterialId;
    bool m_currentKeyMaterialIdHasBeenSet = false;
  };
 
} // namespace Model
} // namespace KMS
} // namespace Aws