HostKeyAttributes.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/lightsail/Lightsail_EXPORTS.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Lightsail {
namespace Model {
 
class HostKeyAttributes {
 public:
  AWS_LIGHTSAIL_API HostKeyAttributes() = default;
  AWS_LIGHTSAIL_API HostKeyAttributes(Aws::Utils::Json::JsonView jsonValue);
  AWS_LIGHTSAIL_API HostKeyAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_LIGHTSAIL_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAlgorithm() const { return m_algorithm; }
  inline bool AlgorithmHasBeenSet() const { return m_algorithmHasBeenSet; }
  template <typename AlgorithmT = Aws::String>
  void SetAlgorithm(AlgorithmT&& value) {
    m_algorithmHasBeenSet = true;
    m_algorithm = std::forward<AlgorithmT>(value);
  }
  template <typename AlgorithmT = Aws::String>
  HostKeyAttributes& WithAlgorithm(AlgorithmT&& value) {
    SetAlgorithm(std::forward<AlgorithmT>(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>
  HostKeyAttributes& WithPublicKey(PublicKeyT&& value) {
    SetPublicKey(std::forward<PublicKeyT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetWitnessedAt() const { return m_witnessedAt; }
  inline bool WitnessedAtHasBeenSet() const { return m_witnessedAtHasBeenSet; }
  template <typename WitnessedAtT = Aws::Utils::DateTime>
  void SetWitnessedAt(WitnessedAtT&& value) {
    m_witnessedAtHasBeenSet = true;
    m_witnessedAt = std::forward<WitnessedAtT>(value);
  }
  template <typename WitnessedAtT = Aws::Utils::DateTime>
  HostKeyAttributes& WithWitnessedAt(WitnessedAtT&& value) {
    SetWitnessedAt(std::forward<WitnessedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFingerprintSHA1() const { return m_fingerprintSHA1; }
  inline bool FingerprintSHA1HasBeenSet() const { return m_fingerprintSHA1HasBeenSet; }
  template <typename FingerprintSHA1T = Aws::String>
  void SetFingerprintSHA1(FingerprintSHA1T&& value) {
    m_fingerprintSHA1HasBeenSet = true;
    m_fingerprintSHA1 = std::forward<FingerprintSHA1T>(value);
  }
  template <typename FingerprintSHA1T = Aws::String>
  HostKeyAttributes& WithFingerprintSHA1(FingerprintSHA1T&& value) {
    SetFingerprintSHA1(std::forward<FingerprintSHA1T>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFingerprintSHA256() const { return m_fingerprintSHA256; }
  inline bool FingerprintSHA256HasBeenSet() const { return m_fingerprintSHA256HasBeenSet; }
  template <typename FingerprintSHA256T = Aws::String>
  void SetFingerprintSHA256(FingerprintSHA256T&& value) {
    m_fingerprintSHA256HasBeenSet = true;
    m_fingerprintSHA256 = std::forward<FingerprintSHA256T>(value);
  }
  template <typename FingerprintSHA256T = Aws::String>
  HostKeyAttributes& WithFingerprintSHA256(FingerprintSHA256T&& value) {
    SetFingerprintSHA256(std::forward<FingerprintSHA256T>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetNotValidBefore() const { return m_notValidBefore; }
  inline bool NotValidBeforeHasBeenSet() const { return m_notValidBeforeHasBeenSet; }
  template <typename NotValidBeforeT = Aws::Utils::DateTime>
  void SetNotValidBefore(NotValidBeforeT&& value) {
    m_notValidBeforeHasBeenSet = true;
    m_notValidBefore = std::forward<NotValidBeforeT>(value);
  }
  template <typename NotValidBeforeT = Aws::Utils::DateTime>
  HostKeyAttributes& WithNotValidBefore(NotValidBeforeT&& value) {
    SetNotValidBefore(std::forward<NotValidBeforeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetNotValidAfter() const { return m_notValidAfter; }
  inline bool NotValidAfterHasBeenSet() const { return m_notValidAfterHasBeenSet; }
  template <typename NotValidAfterT = Aws::Utils::DateTime>
  void SetNotValidAfter(NotValidAfterT&& value) {
    m_notValidAfterHasBeenSet = true;
    m_notValidAfter = std::forward<NotValidAfterT>(value);
  }
  template <typename NotValidAfterT = Aws::Utils::DateTime>
  HostKeyAttributes& WithNotValidAfter(NotValidAfterT&& value) {
    SetNotValidAfter(std::forward<NotValidAfterT>(value));
    return *this;
  }
 private:
  Aws::String m_algorithm;
 
  Aws::String m_publicKey;
 
  Aws::Utils::DateTime m_witnessedAt{};
 
  Aws::String m_fingerprintSHA1;
 
  Aws::String m_fingerprintSHA256;
 
  Aws::Utils::DateTime m_notValidBefore{};
 
  Aws::Utils::DateTime m_notValidAfter{};
  bool m_algorithmHasBeenSet = false;
  bool m_publicKeyHasBeenSet = false;
  bool m_witnessedAtHasBeenSet = false;
  bool m_fingerprintSHA1HasBeenSet = false;
  bool m_fingerprintSHA256HasBeenSet = false;
  bool m_notValidBeforeHasBeenSet = false;
  bool m_notValidAfterHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Lightsail
}  // namespace Aws