KeyBlockHeaders.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/payment-cryptography/PaymentCryptography_EXPORTS.h>
#include <aws/payment-cryptography/model/KeyExportability.h>
#include <aws/payment-cryptography/model/KeyModesOfUse.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace PaymentCryptography {
namespace Model {
 
class KeyBlockHeaders {
 public:
  AWS_PAYMENTCRYPTOGRAPHY_API KeyBlockHeaders() = default;
  AWS_PAYMENTCRYPTOGRAPHY_API KeyBlockHeaders(Aws::Utils::Json::JsonView jsonValue);
  AWS_PAYMENTCRYPTOGRAPHY_API KeyBlockHeaders& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_PAYMENTCRYPTOGRAPHY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const KeyModesOfUse& GetKeyModesOfUse() const { return m_keyModesOfUse; }
  inline bool KeyModesOfUseHasBeenSet() const { return m_keyModesOfUseHasBeenSet; }
  template <typename KeyModesOfUseT = KeyModesOfUse>
  void SetKeyModesOfUse(KeyModesOfUseT&& value) {
    m_keyModesOfUseHasBeenSet = true;
    m_keyModesOfUse = std::forward<KeyModesOfUseT>(value);
  }
  template <typename KeyModesOfUseT = KeyModesOfUse>
  KeyBlockHeaders& WithKeyModesOfUse(KeyModesOfUseT&& value) {
    SetKeyModesOfUse(std::forward<KeyModesOfUseT>(value));
    return *this;
  }
 
 
  inline KeyExportability GetKeyExportability() const { return m_keyExportability; }
  inline bool KeyExportabilityHasBeenSet() const { return m_keyExportabilityHasBeenSet; }
  inline void SetKeyExportability(KeyExportability value) {
    m_keyExportabilityHasBeenSet = true;
    m_keyExportability = value;
  }
  inline KeyBlockHeaders& WithKeyExportability(KeyExportability value) {
    SetKeyExportability(value);
    return *this;
  }
 
 
  inline const Aws::String& GetKeyVersion() const { return m_keyVersion; }
  inline bool KeyVersionHasBeenSet() const { return m_keyVersionHasBeenSet; }
  template <typename KeyVersionT = Aws::String>
  void SetKeyVersion(KeyVersionT&& value) {
    m_keyVersionHasBeenSet = true;
    m_keyVersion = std::forward<KeyVersionT>(value);
  }
  template <typename KeyVersionT = Aws::String>
  KeyBlockHeaders& WithKeyVersion(KeyVersionT&& value) {
    SetKeyVersion(std::forward<KeyVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetOptionalBlocks() const { return m_optionalBlocks; }
  inline bool OptionalBlocksHasBeenSet() const { return m_optionalBlocksHasBeenSet; }
  template <typename OptionalBlocksT = Aws::Map<Aws::String, Aws::String>>
  void SetOptionalBlocks(OptionalBlocksT&& value) {
    m_optionalBlocksHasBeenSet = true;
    m_optionalBlocks = std::forward<OptionalBlocksT>(value);
  }
  template <typename OptionalBlocksT = Aws::Map<Aws::String, Aws::String>>
  KeyBlockHeaders& WithOptionalBlocks(OptionalBlocksT&& value) {
    SetOptionalBlocks(std::forward<OptionalBlocksT>(value));
    return *this;
  }
  template <typename OptionalBlocksKeyT = Aws::String, typename OptionalBlocksValueT = Aws::String>
  KeyBlockHeaders& AddOptionalBlocks(OptionalBlocksKeyT&& key, OptionalBlocksValueT&& value) {
    m_optionalBlocksHasBeenSet = true;
    m_optionalBlocks.emplace(std::forward<OptionalBlocksKeyT>(key), std::forward<OptionalBlocksValueT>(value));
    return *this;
  }
 private:
  KeyModesOfUse m_keyModesOfUse;
 
  KeyExportability m_keyExportability{KeyExportability::NOT_SET};
 
  Aws::String m_keyVersion;
 
  Aws::Map<Aws::String, Aws::String> m_optionalBlocks;
  bool m_keyModesOfUseHasBeenSet = false;
  bool m_keyExportabilityHasBeenSet = false;
  bool m_keyVersionHasBeenSet = false;
  bool m_optionalBlocksHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace PaymentCryptography
}  // namespace Aws