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();
    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; }
    inline void SetAWSAccountId(const Aws::String& value) { m_aWSAccountIdHasBeenSet = true; m_aWSAccountId = value; }
    inline void SetAWSAccountId(Aws::String&& value) { m_aWSAccountIdHasBeenSet = true; m_aWSAccountId = std::move(value); }
    inline void SetAWSAccountId(const char* value) { m_aWSAccountIdHasBeenSet = true; m_aWSAccountId.assign(value); }
    inline KeyMetadata& WithAWSAccountId(const Aws::String& value) { SetAWSAccountId(value); return *this;}
    inline KeyMetadata& WithAWSAccountId(Aws::String&& value) { SetAWSAccountId(std::move(value)); return *this;}
    inline KeyMetadata& WithAWSAccountId(const char* value) { SetAWSAccountId(value); return *this;}
 
 
    inline const Aws::String& GetKeyId() const{ return m_keyId; }
    inline bool KeyIdHasBeenSet() const { return m_keyIdHasBeenSet; }
    inline void SetKeyId(const Aws::String& value) { m_keyIdHasBeenSet = true; m_keyId = value; }
    inline void SetKeyId(Aws::String&& value) { m_keyIdHasBeenSet = true; m_keyId = std::move(value); }
    inline void SetKeyId(const char* value) { m_keyIdHasBeenSet = true; m_keyId.assign(value); }
    inline KeyMetadata& WithKeyId(const Aws::String& value) { SetKeyId(value); return *this;}
    inline KeyMetadata& WithKeyId(Aws::String&& value) { SetKeyId(std::move(value)); return *this;}
    inline KeyMetadata& WithKeyId(const char* value) { SetKeyId(value); return *this;}
 
 
    inline const Aws::String& GetArn() const{ return m_arn; }
    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
    inline KeyMetadata& WithArn(const Aws::String& value) { SetArn(value); return *this;}
    inline KeyMetadata& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
    inline KeyMetadata& WithArn(const char* value) { SetArn(value); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetCreationDate() const{ return m_creationDate; }
    inline bool CreationDateHasBeenSet() const { return m_creationDateHasBeenSet; }
    inline void SetCreationDate(const Aws::Utils::DateTime& value) { m_creationDateHasBeenSet = true; m_creationDate = value; }
    inline void SetCreationDate(Aws::Utils::DateTime&& value) { m_creationDateHasBeenSet = true; m_creationDate = std::move(value); }
    inline KeyMetadata& WithCreationDate(const Aws::Utils::DateTime& value) { SetCreationDate(value); return *this;}
    inline KeyMetadata& WithCreationDate(Aws::Utils::DateTime&& value) { SetCreationDate(std::move(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; }
    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
    inline KeyMetadata& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
    inline KeyMetadata& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
    inline KeyMetadata& WithDescription(const char* value) { SetDescription(value); return *this;}
 
 
    inline const KeyUsageType& GetKeyUsage() const{ return m_keyUsage; }
    inline bool KeyUsageHasBeenSet() const { return m_keyUsageHasBeenSet; }
    inline void SetKeyUsage(const KeyUsageType& value) { m_keyUsageHasBeenSet = true; m_keyUsage = value; }
    inline void SetKeyUsage(KeyUsageType&& value) { m_keyUsageHasBeenSet = true; m_keyUsage = std::move(value); }
    inline KeyMetadata& WithKeyUsage(const KeyUsageType& value) { SetKeyUsage(value); return *this;}
    inline KeyMetadata& WithKeyUsage(KeyUsageType&& value) { SetKeyUsage(std::move(value)); return *this;}
 
 
    inline const KeyState& GetKeyState() const{ return m_keyState; }
    inline bool KeyStateHasBeenSet() const { return m_keyStateHasBeenSet; }
    inline void SetKeyState(const KeyState& value) { m_keyStateHasBeenSet = true; m_keyState = value; }
    inline void SetKeyState(KeyState&& value) { m_keyStateHasBeenSet = true; m_keyState = std::move(value); }
    inline KeyMetadata& WithKeyState(const KeyState& value) { SetKeyState(value); return *this;}
    inline KeyMetadata& WithKeyState(KeyState&& value) { SetKeyState(std::move(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetDeletionDate() const{ return m_deletionDate; }
    inline bool DeletionDateHasBeenSet() const { return m_deletionDateHasBeenSet; }
    inline void SetDeletionDate(const Aws::Utils::DateTime& value) { m_deletionDateHasBeenSet = true; m_deletionDate = value; }
    inline void SetDeletionDate(Aws::Utils::DateTime&& value) { m_deletionDateHasBeenSet = true; m_deletionDate = std::move(value); }
    inline KeyMetadata& WithDeletionDate(const Aws::Utils::DateTime& value) { SetDeletionDate(value); return *this;}
    inline KeyMetadata& WithDeletionDate(Aws::Utils::DateTime&& value) { SetDeletionDate(std::move(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetValidTo() const{ return m_validTo; }
    inline bool ValidToHasBeenSet() const { return m_validToHasBeenSet; }
    inline void SetValidTo(const Aws::Utils::DateTime& value) { m_validToHasBeenSet = true; m_validTo = value; }
    inline void SetValidTo(Aws::Utils::DateTime&& value) { m_validToHasBeenSet = true; m_validTo = std::move(value); }
    inline KeyMetadata& WithValidTo(const Aws::Utils::DateTime& value) { SetValidTo(value); return *this;}
    inline KeyMetadata& WithValidTo(Aws::Utils::DateTime&& value) { SetValidTo(std::move(value)); return *this;}
 
 
    inline const OriginType& GetOrigin() const{ return m_origin; }
    inline bool OriginHasBeenSet() const { return m_originHasBeenSet; }
    inline void SetOrigin(const OriginType& value) { m_originHasBeenSet = true; m_origin = value; }
    inline void SetOrigin(OriginType&& value) { m_originHasBeenSet = true; m_origin = std::move(value); }
    inline KeyMetadata& WithOrigin(const OriginType& value) { SetOrigin(value); return *this;}
    inline KeyMetadata& WithOrigin(OriginType&& value) { SetOrigin(std::move(value)); return *this;}
 
 
    inline const Aws::String& GetCustomKeyStoreId() const{ return m_customKeyStoreId; }
    inline bool CustomKeyStoreIdHasBeenSet() const { return m_customKeyStoreIdHasBeenSet; }
    inline void SetCustomKeyStoreId(const Aws::String& value) { m_customKeyStoreIdHasBeenSet = true; m_customKeyStoreId = value; }
    inline void SetCustomKeyStoreId(Aws::String&& value) { m_customKeyStoreIdHasBeenSet = true; m_customKeyStoreId = std::move(value); }
    inline void SetCustomKeyStoreId(const char* value) { m_customKeyStoreIdHasBeenSet = true; m_customKeyStoreId.assign(value); }
    inline KeyMetadata& WithCustomKeyStoreId(const Aws::String& value) { SetCustomKeyStoreId(value); return *this;}
    inline KeyMetadata& WithCustomKeyStoreId(Aws::String&& value) { SetCustomKeyStoreId(std::move(value)); return *this;}
    inline KeyMetadata& WithCustomKeyStoreId(const char* value) { SetCustomKeyStoreId(value); return *this;}
 
 
    inline const Aws::String& GetCloudHsmClusterId() const{ return m_cloudHsmClusterId; }
    inline bool CloudHsmClusterIdHasBeenSet() const { return m_cloudHsmClusterIdHasBeenSet; }
    inline void SetCloudHsmClusterId(const Aws::String& value) { m_cloudHsmClusterIdHasBeenSet = true; m_cloudHsmClusterId = value; }
    inline void SetCloudHsmClusterId(Aws::String&& value) { m_cloudHsmClusterIdHasBeenSet = true; m_cloudHsmClusterId = std::move(value); }
    inline void SetCloudHsmClusterId(const char* value) { m_cloudHsmClusterIdHasBeenSet = true; m_cloudHsmClusterId.assign(value); }
    inline KeyMetadata& WithCloudHsmClusterId(const Aws::String& value) { SetCloudHsmClusterId(value); return *this;}
    inline KeyMetadata& WithCloudHsmClusterId(Aws::String&& value) { SetCloudHsmClusterId(std::move(value)); return *this;}
    inline KeyMetadata& WithCloudHsmClusterId(const char* value) { SetCloudHsmClusterId(value); return *this;}
 
 
    inline const ExpirationModelType& GetExpirationModel() const{ return m_expirationModel; }
    inline bool ExpirationModelHasBeenSet() const { return m_expirationModelHasBeenSet; }
    inline void SetExpirationModel(const ExpirationModelType& value) { m_expirationModelHasBeenSet = true; m_expirationModel = value; }
    inline void SetExpirationModel(ExpirationModelType&& value) { m_expirationModelHasBeenSet = true; m_expirationModel = std::move(value); }
    inline KeyMetadata& WithExpirationModel(const ExpirationModelType& value) { SetExpirationModel(value); return *this;}
    inline KeyMetadata& WithExpirationModel(ExpirationModelType&& value) { SetExpirationModel(std::move(value)); return *this;}
 
 
    inline const KeyManagerType& GetKeyManager() const{ return m_keyManager; }
    inline bool KeyManagerHasBeenSet() const { return m_keyManagerHasBeenSet; }
    inline void SetKeyManager(const KeyManagerType& value) { m_keyManagerHasBeenSet = true; m_keyManager = value; }
    inline void SetKeyManager(KeyManagerType&& value) { m_keyManagerHasBeenSet = true; m_keyManager = std::move(value); }
    inline KeyMetadata& WithKeyManager(const KeyManagerType& value) { SetKeyManager(value); return *this;}
    inline KeyMetadata& WithKeyManager(KeyManagerType&& value) { SetKeyManager(std::move(value)); return *this;}
 
 
    inline const KeySpec& GetKeySpec() const{ return m_keySpec; }
    inline bool KeySpecHasBeenSet() const { return m_keySpecHasBeenSet; }
    inline void SetKeySpec(const KeySpec& value) { m_keySpecHasBeenSet = true; m_keySpec = value; }
    inline void SetKeySpec(KeySpec&& value) { m_keySpecHasBeenSet = true; m_keySpec = std::move(value); }
    inline KeyMetadata& WithKeySpec(const KeySpec& value) { SetKeySpec(value); return *this;}
    inline KeyMetadata& WithKeySpec(KeySpec&& value) { SetKeySpec(std::move(value)); return *this;}
 
 
    inline const Aws::Vector<EncryptionAlgorithmSpec>& GetEncryptionAlgorithms() const{ return m_encryptionAlgorithms; }
    inline bool EncryptionAlgorithmsHasBeenSet() const { return m_encryptionAlgorithmsHasBeenSet; }
    inline void SetEncryptionAlgorithms(const Aws::Vector<EncryptionAlgorithmSpec>& value) { m_encryptionAlgorithmsHasBeenSet = true; m_encryptionAlgorithms = value; }
    inline void SetEncryptionAlgorithms(Aws::Vector<EncryptionAlgorithmSpec>&& value) { m_encryptionAlgorithmsHasBeenSet = true; m_encryptionAlgorithms = std::move(value); }
    inline KeyMetadata& WithEncryptionAlgorithms(const Aws::Vector<EncryptionAlgorithmSpec>& value) { SetEncryptionAlgorithms(value); return *this;}
    inline KeyMetadata& WithEncryptionAlgorithms(Aws::Vector<EncryptionAlgorithmSpec>&& value) { SetEncryptionAlgorithms(std::move(value)); return *this;}
    inline KeyMetadata& AddEncryptionAlgorithms(const EncryptionAlgorithmSpec& value) { m_encryptionAlgorithmsHasBeenSet = true; m_encryptionAlgorithms.push_back(value); return *this; }
    inline KeyMetadata& AddEncryptionAlgorithms(EncryptionAlgorithmSpec&& value) { m_encryptionAlgorithmsHasBeenSet = true; m_encryptionAlgorithms.push_back(std::move(value)); return *this; }
 
 
    inline const Aws::Vector<SigningAlgorithmSpec>& GetSigningAlgorithms() const{ return m_signingAlgorithms; }
    inline bool SigningAlgorithmsHasBeenSet() const { return m_signingAlgorithmsHasBeenSet; }
    inline void SetSigningAlgorithms(const Aws::Vector<SigningAlgorithmSpec>& value) { m_signingAlgorithmsHasBeenSet = true; m_signingAlgorithms = value; }
    inline void SetSigningAlgorithms(Aws::Vector<SigningAlgorithmSpec>&& value) { m_signingAlgorithmsHasBeenSet = true; m_signingAlgorithms = std::move(value); }
    inline KeyMetadata& WithSigningAlgorithms(const Aws::Vector<SigningAlgorithmSpec>& value) { SetSigningAlgorithms(value); return *this;}
    inline KeyMetadata& WithSigningAlgorithms(Aws::Vector<SigningAlgorithmSpec>&& value) { SetSigningAlgorithms(std::move(value)); return *this;}
    inline KeyMetadata& AddSigningAlgorithms(const SigningAlgorithmSpec& value) { m_signingAlgorithmsHasBeenSet = true; m_signingAlgorithms.push_back(value); return *this; }
    inline KeyMetadata& AddSigningAlgorithms(SigningAlgorithmSpec&& value) { m_signingAlgorithmsHasBeenSet = true; m_signingAlgorithms.push_back(std::move(value)); return *this; }
 
 
    inline const Aws::Vector<KeyAgreementAlgorithmSpec>& GetKeyAgreementAlgorithms() const{ return m_keyAgreementAlgorithms; }
    inline bool KeyAgreementAlgorithmsHasBeenSet() const { return m_keyAgreementAlgorithmsHasBeenSet; }
    inline void SetKeyAgreementAlgorithms(const Aws::Vector<KeyAgreementAlgorithmSpec>& value) { m_keyAgreementAlgorithmsHasBeenSet = true; m_keyAgreementAlgorithms = value; }
    inline void SetKeyAgreementAlgorithms(Aws::Vector<KeyAgreementAlgorithmSpec>&& value) { m_keyAgreementAlgorithmsHasBeenSet = true; m_keyAgreementAlgorithms = std::move(value); }
    inline KeyMetadata& WithKeyAgreementAlgorithms(const Aws::Vector<KeyAgreementAlgorithmSpec>& value) { SetKeyAgreementAlgorithms(value); return *this;}
    inline KeyMetadata& WithKeyAgreementAlgorithms(Aws::Vector<KeyAgreementAlgorithmSpec>&& value) { SetKeyAgreementAlgorithms(std::move(value)); return *this;}
    inline KeyMetadata& AddKeyAgreementAlgorithms(const KeyAgreementAlgorithmSpec& value) { m_keyAgreementAlgorithmsHasBeenSet = true; m_keyAgreementAlgorithms.push_back(value); return *this; }
    inline KeyMetadata& AddKeyAgreementAlgorithms(KeyAgreementAlgorithmSpec&& value) { m_keyAgreementAlgorithmsHasBeenSet = true; m_keyAgreementAlgorithms.push_back(std::move(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; }
    inline void SetMultiRegionConfiguration(const MultiRegionConfiguration& value) { m_multiRegionConfigurationHasBeenSet = true; m_multiRegionConfiguration = value; }
    inline void SetMultiRegionConfiguration(MultiRegionConfiguration&& value) { m_multiRegionConfigurationHasBeenSet = true; m_multiRegionConfiguration = std::move(value); }
    inline KeyMetadata& WithMultiRegionConfiguration(const MultiRegionConfiguration& value) { SetMultiRegionConfiguration(value); return *this;}
    inline KeyMetadata& WithMultiRegionConfiguration(MultiRegionConfiguration&& value) { SetMultiRegionConfiguration(std::move(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; }
    inline void SetMacAlgorithms(const Aws::Vector<MacAlgorithmSpec>& value) { m_macAlgorithmsHasBeenSet = true; m_macAlgorithms = value; }
    inline void SetMacAlgorithms(Aws::Vector<MacAlgorithmSpec>&& value) { m_macAlgorithmsHasBeenSet = true; m_macAlgorithms = std::move(value); }
    inline KeyMetadata& WithMacAlgorithms(const Aws::Vector<MacAlgorithmSpec>& value) { SetMacAlgorithms(value); return *this;}
    inline KeyMetadata& WithMacAlgorithms(Aws::Vector<MacAlgorithmSpec>&& value) { SetMacAlgorithms(std::move(value)); return *this;}
    inline KeyMetadata& AddMacAlgorithms(const MacAlgorithmSpec& value) { m_macAlgorithmsHasBeenSet = true; m_macAlgorithms.push_back(value); return *this; }
    inline KeyMetadata& AddMacAlgorithms(MacAlgorithmSpec&& value) { m_macAlgorithmsHasBeenSet = true; m_macAlgorithms.push_back(std::move(value)); return *this; }
 
 
    inline const XksKeyConfigurationType& GetXksKeyConfiguration() const{ return m_xksKeyConfiguration; }
    inline bool XksKeyConfigurationHasBeenSet() const { return m_xksKeyConfigurationHasBeenSet; }
    inline void SetXksKeyConfiguration(const XksKeyConfigurationType& value) { m_xksKeyConfigurationHasBeenSet = true; m_xksKeyConfiguration = value; }
    inline void SetXksKeyConfiguration(XksKeyConfigurationType&& value) { m_xksKeyConfigurationHasBeenSet = true; m_xksKeyConfiguration = std::move(value); }
    inline KeyMetadata& WithXksKeyConfiguration(const XksKeyConfigurationType& value) { SetXksKeyConfiguration(value); return *this;}
    inline KeyMetadata& WithXksKeyConfiguration(XksKeyConfigurationType&& value) { SetXksKeyConfiguration(std::move(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;
    bool m_enabledHasBeenSet = false;
 
    Aws::String m_description;
    bool m_descriptionHasBeenSet = false;
 
    KeyUsageType m_keyUsage;
    bool m_keyUsageHasBeenSet = false;
 
    KeyState m_keyState;
    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;
    bool m_originHasBeenSet = false;
 
    Aws::String m_customKeyStoreId;
    bool m_customKeyStoreIdHasBeenSet = false;
 
    Aws::String m_cloudHsmClusterId;
    bool m_cloudHsmClusterIdHasBeenSet = false;
 
    ExpirationModelType m_expirationModel;
    bool m_expirationModelHasBeenSet = false;
 
    KeyManagerType m_keyManager;
    bool m_keyManagerHasBeenSet = false;
 
    KeySpec m_keySpec;
    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;
    bool m_multiRegionHasBeenSet = false;
 
    MultiRegionConfiguration m_multiRegionConfiguration;
    bool m_multiRegionConfigurationHasBeenSet = false;
 
    int m_pendingDeletionWindowInDays;
    bool m_pendingDeletionWindowInDaysHasBeenSet = false;
 
    Aws::Vector<MacAlgorithmSpec> m_macAlgorithms;
    bool m_macAlgorithmsHasBeenSet = false;
 
    XksKeyConfigurationType m_xksKeyConfiguration;
    bool m_xksKeyConfigurationHasBeenSet = false;
  };
 
} // namespace Model
} // namespace KMS
} // namespace Aws