KeySigningKey.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/route53/Route53_EXPORTS.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;
 
  Aws::String m_kmsArn;
 
  int m_flag{0};
 
  Aws::String m_signingAlgorithmMnemonic;
 
  int m_signingAlgorithmType{0};
 
  Aws::String m_digestAlgorithmMnemonic;
 
  int m_digestAlgorithmType{0};
 
  int m_keyTag{0};
 
  Aws::String m_digestValue;
 
  Aws::String m_publicKey;
 
  Aws::String m_dSRecord;
 
  Aws::String m_dNSKEYRecord;
 
  Aws::String m_status;
 
  Aws::String m_statusMessage;
 
  Aws::Utils::DateTime m_createdDate{};
 
  Aws::Utils::DateTime m_lastModifiedDate{};
  bool m_nameHasBeenSet = false;
  bool m_kmsArnHasBeenSet = false;
  bool m_flagHasBeenSet = false;
  bool m_signingAlgorithmMnemonicHasBeenSet = false;
  bool m_signingAlgorithmTypeHasBeenSet = false;
  bool m_digestAlgorithmMnemonicHasBeenSet = false;
  bool m_digestAlgorithmTypeHasBeenSet = false;
  bool m_keyTagHasBeenSet = false;
  bool m_digestValueHasBeenSet = false;
  bool m_publicKeyHasBeenSet = false;
  bool m_dSRecordHasBeenSet = false;
  bool m_dNSKEYRecordHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_statusMessageHasBeenSet = false;
  bool m_createdDateHasBeenSet = false;
  bool m_lastModifiedDateHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Route53
}  // namespace Aws