KeySigningKey.h

 
#pragma once
#include <aws/route53/Route53_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/DateTime.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Xml
{
  class XmlNode;
} // namespace Xml
} // namespace Utils
namespace Route53
{
namespace Model
{
 
  class KeySigningKey
  {
  public:
    AWS_ROUTE53_API KeySigningKey() = default;
    AWS_ROUTE53_API KeySigningKey(const Aws::Utils::Xml::XmlNode& xmlNode);
    AWS_ROUTE53_API KeySigningKey& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
    AWS_ROUTE53_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
 
 
 
    inline const Aws::String& GetName() const { return m_name; }
    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
    template<typename NameT = Aws::String>
    void SetName(NameT&& value) { m_nameHasBeenSet = true; m_name = std::forward<NameT>(value); }
    template<typename NameT = Aws::String>
    KeySigningKey& WithName(NameT&& value) { SetName(std::forward<NameT>(value)); return *this;}
 
 
    inline const Aws::String& GetKmsArn() const { return m_kmsArn; }
    inline bool KmsArnHasBeenSet() const { return m_kmsArnHasBeenSet; }
    template<typename KmsArnT = Aws::String>
    void SetKmsArn(KmsArnT&& value) { m_kmsArnHasBeenSet = true; m_kmsArn = std::forward<KmsArnT>(value); }
    template<typename KmsArnT = Aws::String>
    KeySigningKey& WithKmsArn(KmsArnT&& value) { SetKmsArn(std::forward<KmsArnT>(value)); return *this;}
 
 
    inline int GetFlag() const { return m_flag; }
    inline bool FlagHasBeenSet() const { return m_flagHasBeenSet; }
    inline void SetFlag(int value) { m_flagHasBeenSet = true; m_flag = value; }
    inline KeySigningKey& WithFlag(int value) { SetFlag(value); return *this;}
 
 
    inline const Aws::String& GetSigningAlgorithmMnemonic() const { return m_signingAlgorithmMnemonic; }
    inline bool SigningAlgorithmMnemonicHasBeenSet() const { return m_signingAlgorithmMnemonicHasBeenSet; }
    template<typename SigningAlgorithmMnemonicT = Aws::String>
    void SetSigningAlgorithmMnemonic(SigningAlgorithmMnemonicT&& value) { m_signingAlgorithmMnemonicHasBeenSet = true; m_signingAlgorithmMnemonic = std::forward<SigningAlgorithmMnemonicT>(value); }
    template<typename SigningAlgorithmMnemonicT = Aws::String>
    KeySigningKey& WithSigningAlgorithmMnemonic(SigningAlgorithmMnemonicT&& value) { SetSigningAlgorithmMnemonic(std::forward<SigningAlgorithmMnemonicT>(value)); return *this;}
 
 
    inline int GetSigningAlgorithmType() const { return m_signingAlgorithmType; }
    inline bool SigningAlgorithmTypeHasBeenSet() const { return m_signingAlgorithmTypeHasBeenSet; }
    inline void SetSigningAlgorithmType(int value) { m_signingAlgorithmTypeHasBeenSet = true; m_signingAlgorithmType = value; }
    inline KeySigningKey& WithSigningAlgorithmType(int value) { SetSigningAlgorithmType(value); return *this;}
 
 
    inline const Aws::String& GetDigestAlgorithmMnemonic() const { return m_digestAlgorithmMnemonic; }
    inline bool DigestAlgorithmMnemonicHasBeenSet() const { return m_digestAlgorithmMnemonicHasBeenSet; }
    template<typename DigestAlgorithmMnemonicT = Aws::String>
    void SetDigestAlgorithmMnemonic(DigestAlgorithmMnemonicT&& value) { m_digestAlgorithmMnemonicHasBeenSet = true; m_digestAlgorithmMnemonic = std::forward<DigestAlgorithmMnemonicT>(value); }
    template<typename DigestAlgorithmMnemonicT = Aws::String>
    KeySigningKey& WithDigestAlgorithmMnemonic(DigestAlgorithmMnemonicT&& value) { SetDigestAlgorithmMnemonic(std::forward<DigestAlgorithmMnemonicT>(value)); return *this;}
 
 
    inline int GetDigestAlgorithmType() const { return m_digestAlgorithmType; }
    inline bool DigestAlgorithmTypeHasBeenSet() const { return m_digestAlgorithmTypeHasBeenSet; }
    inline void SetDigestAlgorithmType(int value) { m_digestAlgorithmTypeHasBeenSet = true; m_digestAlgorithmType = value; }
    inline KeySigningKey& WithDigestAlgorithmType(int value) { SetDigestAlgorithmType(value); return *this;}
 
 
    inline int GetKeyTag() const { return m_keyTag; }
    inline bool KeyTagHasBeenSet() const { return m_keyTagHasBeenSet; }
    inline void SetKeyTag(int value) { m_keyTagHasBeenSet = true; m_keyTag = value; }
    inline KeySigningKey& WithKeyTag(int value) { SetKeyTag(value); return *this;}
 
 
    inline const Aws::String& GetDigestValue() const { return m_digestValue; }
    inline bool DigestValueHasBeenSet() const { return m_digestValueHasBeenSet; }
    template<typename DigestValueT = Aws::String>
    void SetDigestValue(DigestValueT&& value) { m_digestValueHasBeenSet = true; m_digestValue = std::forward<DigestValueT>(value); }
    template<typename DigestValueT = Aws::String>
    KeySigningKey& WithDigestValue(DigestValueT&& value) { SetDigestValue(std::forward<DigestValueT>(value)); return *this;}
 
 
    inline const Aws::String& GetPublicKey() const { return m_publicKey; }
    inline bool PublicKeyHasBeenSet() const { return m_publicKeyHasBeenSet; }
    template<typename PublicKeyT = Aws::String>
    void SetPublicKey(PublicKeyT&& value) { m_publicKeyHasBeenSet = true; m_publicKey = std::forward<PublicKeyT>(value); }
    template<typename PublicKeyT = Aws::String>
    KeySigningKey& WithPublicKey(PublicKeyT&& value) { SetPublicKey(std::forward<PublicKeyT>(value)); return *this;}
 
 
    inline const Aws::String& GetDSRecord() const { return m_dSRecord; }
    inline bool DSRecordHasBeenSet() const { return m_dSRecordHasBeenSet; }
    template<typename DSRecordT = Aws::String>
    void SetDSRecord(DSRecordT&& value) { m_dSRecordHasBeenSet = true; m_dSRecord = std::forward<DSRecordT>(value); }
    template<typename DSRecordT = Aws::String>
    KeySigningKey& WithDSRecord(DSRecordT&& value) { SetDSRecord(std::forward<DSRecordT>(value)); return *this;}
 
 
    inline const Aws::String& GetDNSKEYRecord() const { return m_dNSKEYRecord; }
    inline bool DNSKEYRecordHasBeenSet() const { return m_dNSKEYRecordHasBeenSet; }
    template<typename DNSKEYRecordT = Aws::String>
    void SetDNSKEYRecord(DNSKEYRecordT&& value) { m_dNSKEYRecordHasBeenSet = true; m_dNSKEYRecord = std::forward<DNSKEYRecordT>(value); }
    template<typename DNSKEYRecordT = Aws::String>
    KeySigningKey& WithDNSKEYRecord(DNSKEYRecordT&& value) { SetDNSKEYRecord(std::forward<DNSKEYRecordT>(value)); return *this;}
 
 
    inline const Aws::String& GetStatus() const { return m_status; }
    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
    template<typename StatusT = Aws::String>
    void SetStatus(StatusT&& value) { m_statusHasBeenSet = true; m_status = std::forward<StatusT>(value); }
    template<typename StatusT = Aws::String>
    KeySigningKey& WithStatus(StatusT&& value) { SetStatus(std::forward<StatusT>(value)); return *this;}
 
 
    inline const Aws::String& GetStatusMessage() const { return m_statusMessage; }
    inline bool StatusMessageHasBeenSet() const { return m_statusMessageHasBeenSet; }
    template<typename StatusMessageT = Aws::String>
    void SetStatusMessage(StatusMessageT&& value) { m_statusMessageHasBeenSet = true; m_statusMessage = std::forward<StatusMessageT>(value); }
    template<typename StatusMessageT = Aws::String>
    KeySigningKey& WithStatusMessage(StatusMessageT&& value) { SetStatusMessage(std::forward<StatusMessageT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetCreatedDate() const { return m_createdDate; }
    inline bool CreatedDateHasBeenSet() const { return m_createdDateHasBeenSet; }
    template<typename CreatedDateT = Aws::Utils::DateTime>
    void SetCreatedDate(CreatedDateT&& value) { m_createdDateHasBeenSet = true; m_createdDate = std::forward<CreatedDateT>(value); }
    template<typename CreatedDateT = Aws::Utils::DateTime>
    KeySigningKey& WithCreatedDate(CreatedDateT&& value) { SetCreatedDate(std::forward<CreatedDateT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetLastModifiedDate() const { return m_lastModifiedDate; }
    inline bool LastModifiedDateHasBeenSet() const { return m_lastModifiedDateHasBeenSet; }
    template<typename LastModifiedDateT = Aws::Utils::DateTime>
    void SetLastModifiedDate(LastModifiedDateT&& value) { m_lastModifiedDateHasBeenSet = true; m_lastModifiedDate = std::forward<LastModifiedDateT>(value); }
    template<typename LastModifiedDateT = Aws::Utils::DateTime>
    KeySigningKey& WithLastModifiedDate(LastModifiedDateT&& value) { SetLastModifiedDate(std::forward<LastModifiedDateT>(value)); return *this;}
  private:
 
    Aws::String m_name;
    bool m_nameHasBeenSet = false;
 
    Aws::String m_kmsArn;
    bool m_kmsArnHasBeenSet = false;
 
    int m_flag{0};
    bool m_flagHasBeenSet = false;
 
    Aws::String m_signingAlgorithmMnemonic;
    bool m_signingAlgorithmMnemonicHasBeenSet = false;
 
    int m_signingAlgorithmType{0};
    bool m_signingAlgorithmTypeHasBeenSet = false;
 
    Aws::String m_digestAlgorithmMnemonic;
    bool m_digestAlgorithmMnemonicHasBeenSet = false;
 
    int m_digestAlgorithmType{0};
    bool m_digestAlgorithmTypeHasBeenSet = false;
 
    int m_keyTag{0};
    bool m_keyTagHasBeenSet = false;
 
    Aws::String m_digestValue;
    bool m_digestValueHasBeenSet = false;
 
    Aws::String m_publicKey;
    bool m_publicKeyHasBeenSet = false;
 
    Aws::String m_dSRecord;
    bool m_dSRecordHasBeenSet = false;
 
    Aws::String m_dNSKEYRecord;
    bool m_dNSKEYRecordHasBeenSet = false;
 
    Aws::String m_status;
    bool m_statusHasBeenSet = false;
 
    Aws::String m_statusMessage;
    bool m_statusMessageHasBeenSet = false;
 
    Aws::Utils::DateTime m_createdDate{};
    bool m_createdDateHasBeenSet = false;
 
    Aws::Utils::DateTime m_lastModifiedDate{};
    bool m_lastModifiedDateHasBeenSet = false;
  };
 
} // namespace Model
} // namespace Route53
} // namespace Aws