KeySummary.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/payment-cryptography/PaymentCryptography_EXPORTS.h>
#include <aws/payment-cryptography/model/KeyAttributes.h>
#include <aws/payment-cryptography/model/KeyState.h>
#include <aws/payment-cryptography/model/MultiRegionKeyType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace PaymentCryptography {
namespace Model {
 
class KeySummary {
 public:
  AWS_PAYMENTCRYPTOGRAPHY_API KeySummary() = default;
  AWS_PAYMENTCRYPTOGRAPHY_API KeySummary(Aws::Utils::Json::JsonView jsonValue);
  AWS_PAYMENTCRYPTOGRAPHY_API KeySummary& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_PAYMENTCRYPTOGRAPHY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetKeyArn() const { return m_keyArn; }
  inline bool KeyArnHasBeenSet() const { return m_keyArnHasBeenSet; }
  template <typename KeyArnT = Aws::String>
  void SetKeyArn(KeyArnT&& value) {
    m_keyArnHasBeenSet = true;
    m_keyArn = std::forward<KeyArnT>(value);
  }
  template <typename KeyArnT = Aws::String>
  KeySummary& WithKeyArn(KeyArnT&& value) {
    SetKeyArn(std::forward<KeyArnT>(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 KeySummary& WithKeyState(KeyState value) {
    SetKeyState(value);
    return *this;
  }
 
 
  inline const KeyAttributes& GetKeyAttributes() const { return m_keyAttributes; }
  inline bool KeyAttributesHasBeenSet() const { return m_keyAttributesHasBeenSet; }
  template <typename KeyAttributesT = KeyAttributes>
  void SetKeyAttributes(KeyAttributesT&& value) {
    m_keyAttributesHasBeenSet = true;
    m_keyAttributes = std::forward<KeyAttributesT>(value);
  }
  template <typename KeyAttributesT = KeyAttributes>
  KeySummary& WithKeyAttributes(KeyAttributesT&& value) {
    SetKeyAttributes(std::forward<KeyAttributesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKeyCheckValue() const { return m_keyCheckValue; }
  inline bool KeyCheckValueHasBeenSet() const { return m_keyCheckValueHasBeenSet; }
  template <typename KeyCheckValueT = Aws::String>
  void SetKeyCheckValue(KeyCheckValueT&& value) {
    m_keyCheckValueHasBeenSet = true;
    m_keyCheckValue = std::forward<KeyCheckValueT>(value);
  }
  template <typename KeyCheckValueT = Aws::String>
  KeySummary& WithKeyCheckValue(KeyCheckValueT&& value) {
    SetKeyCheckValue(std::forward<KeyCheckValueT>(value));
    return *this;
  }
 
 
  inline bool GetExportable() const { return m_exportable; }
  inline bool ExportableHasBeenSet() const { return m_exportableHasBeenSet; }
  inline void SetExportable(bool value) {
    m_exportableHasBeenSet = true;
    m_exportable = value;
  }
  inline KeySummary& WithExportable(bool value) {
    SetExportable(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 KeySummary& WithEnabled(bool value) {
    SetEnabled(value);
    return *this;
  }
 
 
  inline MultiRegionKeyType GetMultiRegionKeyType() const { return m_multiRegionKeyType; }
  inline bool MultiRegionKeyTypeHasBeenSet() const { return m_multiRegionKeyTypeHasBeenSet; }
  inline void SetMultiRegionKeyType(MultiRegionKeyType value) {
    m_multiRegionKeyTypeHasBeenSet = true;
    m_multiRegionKeyType = value;
  }
  inline KeySummary& WithMultiRegionKeyType(MultiRegionKeyType value) {
    SetMultiRegionKeyType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetPrimaryRegion() const { return m_primaryRegion; }
  inline bool PrimaryRegionHasBeenSet() const { return m_primaryRegionHasBeenSet; }
  template <typename PrimaryRegionT = Aws::String>
  void SetPrimaryRegion(PrimaryRegionT&& value) {
    m_primaryRegionHasBeenSet = true;
    m_primaryRegion = std::forward<PrimaryRegionT>(value);
  }
  template <typename PrimaryRegionT = Aws::String>
  KeySummary& WithPrimaryRegion(PrimaryRegionT&& value) {
    SetPrimaryRegion(std::forward<PrimaryRegionT>(value));
    return *this;
  }
 private:
  Aws::String m_keyArn;
 
  KeyState m_keyState{KeyState::NOT_SET};
 
  KeyAttributes m_keyAttributes;
 
  Aws::String m_keyCheckValue;
 
  bool m_exportable{false};
 
  bool m_enabled{false};
 
  MultiRegionKeyType m_multiRegionKeyType{MultiRegionKeyType::NOT_SET};
 
  Aws::String m_primaryRegion;
  bool m_keyArnHasBeenSet = false;
  bool m_keyStateHasBeenSet = false;
  bool m_keyAttributesHasBeenSet = false;
  bool m_keyCheckValueHasBeenSet = false;
  bool m_exportableHasBeenSet = false;
  bool m_enabledHasBeenSet = false;
  bool m_multiRegionKeyTypeHasBeenSet = false;
  bool m_primaryRegionHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace PaymentCryptography
}  // namespace Aws