AwsApiGatewayMethodSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/securityhub/SecurityHub_EXPORTS.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SecurityHub {
namespace Model {
 
class AwsApiGatewayMethodSettings {
 public:
  AWS_SECURITYHUB_API AwsApiGatewayMethodSettings() = default;
  AWS_SECURITYHUB_API AwsApiGatewayMethodSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_SECURITYHUB_API AwsApiGatewayMethodSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SECURITYHUB_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline bool GetMetricsEnabled() const { return m_metricsEnabled; }
  inline bool MetricsEnabledHasBeenSet() const { return m_metricsEnabledHasBeenSet; }
  inline void SetMetricsEnabled(bool value) {
    m_metricsEnabledHasBeenSet = true;
    m_metricsEnabled = value;
  }
  inline AwsApiGatewayMethodSettings& WithMetricsEnabled(bool value) {
    SetMetricsEnabled(value);
    return *this;
  }
 
 
  inline const Aws::String& GetLoggingLevel() const { return m_loggingLevel; }
  inline bool LoggingLevelHasBeenSet() const { return m_loggingLevelHasBeenSet; }
  template <typename LoggingLevelT = Aws::String>
  void SetLoggingLevel(LoggingLevelT&& value) {
    m_loggingLevelHasBeenSet = true;
    m_loggingLevel = std::forward<LoggingLevelT>(value);
  }
  template <typename LoggingLevelT = Aws::String>
  AwsApiGatewayMethodSettings& WithLoggingLevel(LoggingLevelT&& value) {
    SetLoggingLevel(std::forward<LoggingLevelT>(value));
    return *this;
  }
 
 
  inline bool GetDataTraceEnabled() const { return m_dataTraceEnabled; }
  inline bool DataTraceEnabledHasBeenSet() const { return m_dataTraceEnabledHasBeenSet; }
  inline void SetDataTraceEnabled(bool value) {
    m_dataTraceEnabledHasBeenSet = true;
    m_dataTraceEnabled = value;
  }
  inline AwsApiGatewayMethodSettings& WithDataTraceEnabled(bool value) {
    SetDataTraceEnabled(value);
    return *this;
  }
 
 
  inline int GetThrottlingBurstLimit() const { return m_throttlingBurstLimit; }
  inline bool ThrottlingBurstLimitHasBeenSet() const { return m_throttlingBurstLimitHasBeenSet; }
  inline void SetThrottlingBurstLimit(int value) {
    m_throttlingBurstLimitHasBeenSet = true;
    m_throttlingBurstLimit = value;
  }
  inline AwsApiGatewayMethodSettings& WithThrottlingBurstLimit(int value) {
    SetThrottlingBurstLimit(value);
    return *this;
  }
 
 
  inline double GetThrottlingRateLimit() const { return m_throttlingRateLimit; }
  inline bool ThrottlingRateLimitHasBeenSet() const { return m_throttlingRateLimitHasBeenSet; }
  inline void SetThrottlingRateLimit(double value) {
    m_throttlingRateLimitHasBeenSet = true;
    m_throttlingRateLimit = value;
  }
  inline AwsApiGatewayMethodSettings& WithThrottlingRateLimit(double value) {
    SetThrottlingRateLimit(value);
    return *this;
  }
 
 
  inline bool GetCachingEnabled() const { return m_cachingEnabled; }
  inline bool CachingEnabledHasBeenSet() const { return m_cachingEnabledHasBeenSet; }
  inline void SetCachingEnabled(bool value) {
    m_cachingEnabledHasBeenSet = true;
    m_cachingEnabled = value;
  }
  inline AwsApiGatewayMethodSettings& WithCachingEnabled(bool value) {
    SetCachingEnabled(value);
    return *this;
  }
 
 
  inline int GetCacheTtlInSeconds() const { return m_cacheTtlInSeconds; }
  inline bool CacheTtlInSecondsHasBeenSet() const { return m_cacheTtlInSecondsHasBeenSet; }
  inline void SetCacheTtlInSeconds(int value) {
    m_cacheTtlInSecondsHasBeenSet = true;
    m_cacheTtlInSeconds = value;
  }
  inline AwsApiGatewayMethodSettings& WithCacheTtlInSeconds(int value) {
    SetCacheTtlInSeconds(value);
    return *this;
  }
 
 
  inline bool GetCacheDataEncrypted() const { return m_cacheDataEncrypted; }
  inline bool CacheDataEncryptedHasBeenSet() const { return m_cacheDataEncryptedHasBeenSet; }
  inline void SetCacheDataEncrypted(bool value) {
    m_cacheDataEncryptedHasBeenSet = true;
    m_cacheDataEncrypted = value;
  }
  inline AwsApiGatewayMethodSettings& WithCacheDataEncrypted(bool value) {
    SetCacheDataEncrypted(value);
    return *this;
  }
 
 
  inline bool GetRequireAuthorizationForCacheControl() const { return m_requireAuthorizationForCacheControl; }
  inline bool RequireAuthorizationForCacheControlHasBeenSet() const { return m_requireAuthorizationForCacheControlHasBeenSet; }
  inline void SetRequireAuthorizationForCacheControl(bool value) {
    m_requireAuthorizationForCacheControlHasBeenSet = true;
    m_requireAuthorizationForCacheControl = value;
  }
  inline AwsApiGatewayMethodSettings& WithRequireAuthorizationForCacheControl(bool value) {
    SetRequireAuthorizationForCacheControl(value);
    return *this;
  }
 
 
  inline const Aws::String& GetUnauthorizedCacheControlHeaderStrategy() const { return m_unauthorizedCacheControlHeaderStrategy; }
  inline bool UnauthorizedCacheControlHeaderStrategyHasBeenSet() const { return m_unauthorizedCacheControlHeaderStrategyHasBeenSet; }
  template <typename UnauthorizedCacheControlHeaderStrategyT = Aws::String>
  void SetUnauthorizedCacheControlHeaderStrategy(UnauthorizedCacheControlHeaderStrategyT&& value) {
    m_unauthorizedCacheControlHeaderStrategyHasBeenSet = true;
    m_unauthorizedCacheControlHeaderStrategy = std::forward<UnauthorizedCacheControlHeaderStrategyT>(value);
  }
  template <typename UnauthorizedCacheControlHeaderStrategyT = Aws::String>
  AwsApiGatewayMethodSettings& WithUnauthorizedCacheControlHeaderStrategy(UnauthorizedCacheControlHeaderStrategyT&& value) {
    SetUnauthorizedCacheControlHeaderStrategy(std::forward<UnauthorizedCacheControlHeaderStrategyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetHttpMethod() const { return m_httpMethod; }
  inline bool HttpMethodHasBeenSet() const { return m_httpMethodHasBeenSet; }
  template <typename HttpMethodT = Aws::String>
  void SetHttpMethod(HttpMethodT&& value) {
    m_httpMethodHasBeenSet = true;
    m_httpMethod = std::forward<HttpMethodT>(value);
  }
  template <typename HttpMethodT = Aws::String>
  AwsApiGatewayMethodSettings& WithHttpMethod(HttpMethodT&& value) {
    SetHttpMethod(std::forward<HttpMethodT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResourcePath() const { return m_resourcePath; }
  inline bool ResourcePathHasBeenSet() const { return m_resourcePathHasBeenSet; }
  template <typename ResourcePathT = Aws::String>
  void SetResourcePath(ResourcePathT&& value) {
    m_resourcePathHasBeenSet = true;
    m_resourcePath = std::forward<ResourcePathT>(value);
  }
  template <typename ResourcePathT = Aws::String>
  AwsApiGatewayMethodSettings& WithResourcePath(ResourcePathT&& value) {
    SetResourcePath(std::forward<ResourcePathT>(value));
    return *this;
  }
 private:
  bool m_metricsEnabled{false};
 
  Aws::String m_loggingLevel;
 
  bool m_dataTraceEnabled{false};
 
  int m_throttlingBurstLimit{0};
 
  double m_throttlingRateLimit{0.0};
 
  bool m_cachingEnabled{false};
 
  int m_cacheTtlInSeconds{0};
 
  bool m_cacheDataEncrypted{false};
 
  bool m_requireAuthorizationForCacheControl{false};
 
  Aws::String m_unauthorizedCacheControlHeaderStrategy;
 
  Aws::String m_httpMethod;
 
  Aws::String m_resourcePath;
  bool m_metricsEnabledHasBeenSet = false;
  bool m_loggingLevelHasBeenSet = false;
  bool m_dataTraceEnabledHasBeenSet = false;
  bool m_throttlingBurstLimitHasBeenSet = false;
  bool m_throttlingRateLimitHasBeenSet = false;
  bool m_cachingEnabledHasBeenSet = false;
  bool m_cacheTtlInSecondsHasBeenSet = false;
  bool m_cacheDataEncryptedHasBeenSet = false;
  bool m_requireAuthorizationForCacheControlHasBeenSet = false;
  bool m_unauthorizedCacheControlHeaderStrategyHasBeenSet = false;
  bool m_httpMethodHasBeenSet = false;
  bool m_resourcePathHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SecurityHub
}  // namespace Aws