ValidationException.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/ivs/IVS_EXPORTS.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace IVS {
namespace Model {
 
class ValidationException {
 public:
  AWS_IVS_API ValidationException() = default;
  AWS_IVS_API ValidationException(Aws::Utils::Json::JsonView jsonValue);
  AWS_IVS_API ValidationException& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_IVS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAccessControlAllowOrigin() const { return m_accessControlAllowOrigin; }
  inline bool AccessControlAllowOriginHasBeenSet() const { return m_accessControlAllowOriginHasBeenSet; }
  template <typename AccessControlAllowOriginT = Aws::String>
  void SetAccessControlAllowOrigin(AccessControlAllowOriginT&& value) {
    m_accessControlAllowOriginHasBeenSet = true;
    m_accessControlAllowOrigin = std::forward<AccessControlAllowOriginT>(value);
  }
  template <typename AccessControlAllowOriginT = Aws::String>
  ValidationException& WithAccessControlAllowOrigin(AccessControlAllowOriginT&& value) {
    SetAccessControlAllowOrigin(std::forward<AccessControlAllowOriginT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAccessControlExposeHeaders() const { return m_accessControlExposeHeaders; }
  inline bool AccessControlExposeHeadersHasBeenSet() const { return m_accessControlExposeHeadersHasBeenSet; }
  template <typename AccessControlExposeHeadersT = Aws::String>
  void SetAccessControlExposeHeaders(AccessControlExposeHeadersT&& value) {
    m_accessControlExposeHeadersHasBeenSet = true;
    m_accessControlExposeHeaders = std::forward<AccessControlExposeHeadersT>(value);
  }
  template <typename AccessControlExposeHeadersT = Aws::String>
  ValidationException& WithAccessControlExposeHeaders(AccessControlExposeHeadersT&& value) {
    SetAccessControlExposeHeaders(std::forward<AccessControlExposeHeadersT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCacheControl() const { return m_cacheControl; }
  inline bool CacheControlHasBeenSet() const { return m_cacheControlHasBeenSet; }
  template <typename CacheControlT = Aws::String>
  void SetCacheControl(CacheControlT&& value) {
    m_cacheControlHasBeenSet = true;
    m_cacheControl = std::forward<CacheControlT>(value);
  }
  template <typename CacheControlT = Aws::String>
  ValidationException& WithCacheControl(CacheControlT&& value) {
    SetCacheControl(std::forward<CacheControlT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetContentSecurityPolicy() const { return m_contentSecurityPolicy; }
  inline bool ContentSecurityPolicyHasBeenSet() const { return m_contentSecurityPolicyHasBeenSet; }
  template <typename ContentSecurityPolicyT = Aws::String>
  void SetContentSecurityPolicy(ContentSecurityPolicyT&& value) {
    m_contentSecurityPolicyHasBeenSet = true;
    m_contentSecurityPolicy = std::forward<ContentSecurityPolicyT>(value);
  }
  template <typename ContentSecurityPolicyT = Aws::String>
  ValidationException& WithContentSecurityPolicy(ContentSecurityPolicyT&& value) {
    SetContentSecurityPolicy(std::forward<ContentSecurityPolicyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStrictTransportSecurity() const { return m_strictTransportSecurity; }
  inline bool StrictTransportSecurityHasBeenSet() const { return m_strictTransportSecurityHasBeenSet; }
  template <typename StrictTransportSecurityT = Aws::String>
  void SetStrictTransportSecurity(StrictTransportSecurityT&& value) {
    m_strictTransportSecurityHasBeenSet = true;
    m_strictTransportSecurity = std::forward<StrictTransportSecurityT>(value);
  }
  template <typename StrictTransportSecurityT = Aws::String>
  ValidationException& WithStrictTransportSecurity(StrictTransportSecurityT&& value) {
    SetStrictTransportSecurity(std::forward<StrictTransportSecurityT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetXContentTypeOptions() const { return m_xContentTypeOptions; }
  inline bool XContentTypeOptionsHasBeenSet() const { return m_xContentTypeOptionsHasBeenSet; }
  template <typename XContentTypeOptionsT = Aws::String>
  void SetXContentTypeOptions(XContentTypeOptionsT&& value) {
    m_xContentTypeOptionsHasBeenSet = true;
    m_xContentTypeOptions = std::forward<XContentTypeOptionsT>(value);
  }
  template <typename XContentTypeOptionsT = Aws::String>
  ValidationException& WithXContentTypeOptions(XContentTypeOptionsT&& value) {
    SetXContentTypeOptions(std::forward<XContentTypeOptionsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetXFrameOptions() const { return m_xFrameOptions; }
  inline bool XFrameOptionsHasBeenSet() const { return m_xFrameOptionsHasBeenSet; }
  template <typename XFrameOptionsT = Aws::String>
  void SetXFrameOptions(XFrameOptionsT&& value) {
    m_xFrameOptionsHasBeenSet = true;
    m_xFrameOptions = std::forward<XFrameOptionsT>(value);
  }
  template <typename XFrameOptionsT = Aws::String>
  ValidationException& WithXFrameOptions(XFrameOptionsT&& value) {
    SetXFrameOptions(std::forward<XFrameOptionsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetXAmznErrorType() const { return m_xAmznErrorType; }
  inline bool XAmznErrorTypeHasBeenSet() const { return m_xAmznErrorTypeHasBeenSet; }
  template <typename XAmznErrorTypeT = Aws::String>
  void SetXAmznErrorType(XAmznErrorTypeT&& value) {
    m_xAmznErrorTypeHasBeenSet = true;
    m_xAmznErrorType = std::forward<XAmznErrorTypeT>(value);
  }
  template <typename XAmznErrorTypeT = Aws::String>
  ValidationException& WithXAmznErrorType(XAmznErrorTypeT&& value) {
    SetXAmznErrorType(std::forward<XAmznErrorTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExceptionMessage() const { return m_exceptionMessage; }
  inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
  template <typename ExceptionMessageT = Aws::String>
  void SetExceptionMessage(ExceptionMessageT&& value) {
    m_exceptionMessageHasBeenSet = true;
    m_exceptionMessage = std::forward<ExceptionMessageT>(value);
  }
  template <typename ExceptionMessageT = Aws::String>
  ValidationException& WithExceptionMessage(ExceptionMessageT&& value) {
    SetExceptionMessage(std::forward<ExceptionMessageT>(value));
    return *this;
  }
 private:
  Aws::String m_accessControlAllowOrigin;
 
  Aws::String m_accessControlExposeHeaders;
 
  Aws::String m_cacheControl;
 
  Aws::String m_contentSecurityPolicy;
 
  Aws::String m_strictTransportSecurity;
 
  Aws::String m_xContentTypeOptions;
 
  Aws::String m_xFrameOptions;
 
  Aws::String m_xAmznErrorType;
 
  Aws::String m_exceptionMessage;
  bool m_accessControlAllowOriginHasBeenSet = false;
  bool m_accessControlExposeHeadersHasBeenSet = false;
  bool m_cacheControlHasBeenSet = false;
  bool m_contentSecurityPolicyHasBeenSet = false;
  bool m_strictTransportSecurityHasBeenSet = false;
  bool m_xContentTypeOptionsHasBeenSet = false;
  bool m_xFrameOptionsHasBeenSet = false;
  bool m_xAmznErrorTypeHasBeenSet = false;
  bool m_exceptionMessageHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace IVS
}  // namespace Aws