UpdateHealthCheckRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/route53/Route53Request.h>
#include <aws/route53/Route53_EXPORTS.h>
#include <aws/route53/model/AlarmIdentifier.h>
#include <aws/route53/model/HealthCheckRegion.h>
#include <aws/route53/model/InsufficientDataHealthStatus.h>
#include <aws/route53/model/ResettableElementName.h>
 
#include <utility>
 
namespace Aws {
namespace Route53 {
namespace Model {
 
class UpdateHealthCheckRequest : public Route53Request {
 public:
  AWS_ROUTE53_API UpdateHealthCheckRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "UpdateHealthCheck"; }
 
  AWS_ROUTE53_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetHealthCheckId() const { return m_healthCheckId; }
  inline bool HealthCheckIdHasBeenSet() const { return m_healthCheckIdHasBeenSet; }
  template <typename HealthCheckIdT = Aws::String>
  void SetHealthCheckId(HealthCheckIdT&& value) {
    m_healthCheckIdHasBeenSet = true;
    m_healthCheckId = std::forward<HealthCheckIdT>(value);
  }
  template <typename HealthCheckIdT = Aws::String>
  UpdateHealthCheckRequest& WithHealthCheckId(HealthCheckIdT&& value) {
    SetHealthCheckId(std::forward<HealthCheckIdT>(value));
    return *this;
  }
 
 
  inline long long GetHealthCheckVersion() const { return m_healthCheckVersion; }
  inline bool HealthCheckVersionHasBeenSet() const { return m_healthCheckVersionHasBeenSet; }
  inline void SetHealthCheckVersion(long long value) {
    m_healthCheckVersionHasBeenSet = true;
    m_healthCheckVersion = value;
  }
  inline UpdateHealthCheckRequest& WithHealthCheckVersion(long long value) {
    SetHealthCheckVersion(value);
    return *this;
  }
 
 
  inline const Aws::String& GetIPAddress() const { return m_iPAddress; }
  inline bool IPAddressHasBeenSet() const { return m_iPAddressHasBeenSet; }
  template <typename IPAddressT = Aws::String>
  void SetIPAddress(IPAddressT&& value) {
    m_iPAddressHasBeenSet = true;
    m_iPAddress = std::forward<IPAddressT>(value);
  }
  template <typename IPAddressT = Aws::String>
  UpdateHealthCheckRequest& WithIPAddress(IPAddressT&& value) {
    SetIPAddress(std::forward<IPAddressT>(value));
    return *this;
  }
 
 
  inline int GetPort() const { return m_port; }
  inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
  inline void SetPort(int value) {
    m_portHasBeenSet = true;
    m_port = value;
  }
  inline UpdateHealthCheckRequest& WithPort(int value) {
    SetPort(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>
  UpdateHealthCheckRequest& WithResourcePath(ResourcePathT&& value) {
    SetResourcePath(std::forward<ResourcePathT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFullyQualifiedDomainName() const { return m_fullyQualifiedDomainName; }
  inline bool FullyQualifiedDomainNameHasBeenSet() const { return m_fullyQualifiedDomainNameHasBeenSet; }
  template <typename FullyQualifiedDomainNameT = Aws::String>
  void SetFullyQualifiedDomainName(FullyQualifiedDomainNameT&& value) {
    m_fullyQualifiedDomainNameHasBeenSet = true;
    m_fullyQualifiedDomainName = std::forward<FullyQualifiedDomainNameT>(value);
  }
  template <typename FullyQualifiedDomainNameT = Aws::String>
  UpdateHealthCheckRequest& WithFullyQualifiedDomainName(FullyQualifiedDomainNameT&& value) {
    SetFullyQualifiedDomainName(std::forward<FullyQualifiedDomainNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSearchString() const { return m_searchString; }
  inline bool SearchStringHasBeenSet() const { return m_searchStringHasBeenSet; }
  template <typename SearchStringT = Aws::String>
  void SetSearchString(SearchStringT&& value) {
    m_searchStringHasBeenSet = true;
    m_searchString = std::forward<SearchStringT>(value);
  }
  template <typename SearchStringT = Aws::String>
  UpdateHealthCheckRequest& WithSearchString(SearchStringT&& value) {
    SetSearchString(std::forward<SearchStringT>(value));
    return *this;
  }
 
 
  inline int GetFailureThreshold() const { return m_failureThreshold; }
  inline bool FailureThresholdHasBeenSet() const { return m_failureThresholdHasBeenSet; }
  inline void SetFailureThreshold(int value) {
    m_failureThresholdHasBeenSet = true;
    m_failureThreshold = value;
  }
  inline UpdateHealthCheckRequest& WithFailureThreshold(int value) {
    SetFailureThreshold(value);
    return *this;
  }
 
 
  inline bool GetInverted() const { return m_inverted; }
  inline bool InvertedHasBeenSet() const { return m_invertedHasBeenSet; }
  inline void SetInverted(bool value) {
    m_invertedHasBeenSet = true;
    m_inverted = value;
  }
  inline UpdateHealthCheckRequest& WithInverted(bool value) {
    SetInverted(value);
    return *this;
  }
 
 
  inline bool GetDisabled() const { return m_disabled; }
  inline bool DisabledHasBeenSet() const { return m_disabledHasBeenSet; }
  inline void SetDisabled(bool value) {
    m_disabledHasBeenSet = true;
    m_disabled = value;
  }
  inline UpdateHealthCheckRequest& WithDisabled(bool value) {
    SetDisabled(value);
    return *this;
  }
 
 
  inline int GetHealthThreshold() const { return m_healthThreshold; }
  inline bool HealthThresholdHasBeenSet() const { return m_healthThresholdHasBeenSet; }
  inline void SetHealthThreshold(int value) {
    m_healthThresholdHasBeenSet = true;
    m_healthThreshold = value;
  }
  inline UpdateHealthCheckRequest& WithHealthThreshold(int value) {
    SetHealthThreshold(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetChildHealthChecks() const { return m_childHealthChecks; }
  inline bool ChildHealthChecksHasBeenSet() const { return m_childHealthChecksHasBeenSet; }
  template <typename ChildHealthChecksT = Aws::Vector<Aws::String>>
  void SetChildHealthChecks(ChildHealthChecksT&& value) {
    m_childHealthChecksHasBeenSet = true;
    m_childHealthChecks = std::forward<ChildHealthChecksT>(value);
  }
  template <typename ChildHealthChecksT = Aws::Vector<Aws::String>>
  UpdateHealthCheckRequest& WithChildHealthChecks(ChildHealthChecksT&& value) {
    SetChildHealthChecks(std::forward<ChildHealthChecksT>(value));
    return *this;
  }
  template <typename ChildHealthChecksT = Aws::String>
  UpdateHealthCheckRequest& AddChildHealthChecks(ChildHealthChecksT&& value) {
    m_childHealthChecksHasBeenSet = true;
    m_childHealthChecks.emplace_back(std::forward<ChildHealthChecksT>(value));
    return *this;
  }
 
 
  inline bool GetEnableSNI() const { return m_enableSNI; }
  inline bool EnableSNIHasBeenSet() const { return m_enableSNIHasBeenSet; }
  inline void SetEnableSNI(bool value) {
    m_enableSNIHasBeenSet = true;
    m_enableSNI = value;
  }
  inline UpdateHealthCheckRequest& WithEnableSNI(bool value) {
    SetEnableSNI(value);
    return *this;
  }
 
 
  inline const Aws::Vector<HealthCheckRegion>& GetRegions() const { return m_regions; }
  inline bool RegionsHasBeenSet() const { return m_regionsHasBeenSet; }
  template <typename RegionsT = Aws::Vector<HealthCheckRegion>>
  void SetRegions(RegionsT&& value) {
    m_regionsHasBeenSet = true;
    m_regions = std::forward<RegionsT>(value);
  }
  template <typename RegionsT = Aws::Vector<HealthCheckRegion>>
  UpdateHealthCheckRequest& WithRegions(RegionsT&& value) {
    SetRegions(std::forward<RegionsT>(value));
    return *this;
  }
  inline UpdateHealthCheckRequest& AddRegions(HealthCheckRegion value) {
    m_regionsHasBeenSet = true;
    m_regions.push_back(value);
    return *this;
  }
 
 
  inline const AlarmIdentifier& GetAlarmIdentifier() const { return m_alarmIdentifier; }
  inline bool AlarmIdentifierHasBeenSet() const { return m_alarmIdentifierHasBeenSet; }
  template <typename AlarmIdentifierT = AlarmIdentifier>
  void SetAlarmIdentifier(AlarmIdentifierT&& value) {
    m_alarmIdentifierHasBeenSet = true;
    m_alarmIdentifier = std::forward<AlarmIdentifierT>(value);
  }
  template <typename AlarmIdentifierT = AlarmIdentifier>
  UpdateHealthCheckRequest& WithAlarmIdentifier(AlarmIdentifierT&& value) {
    SetAlarmIdentifier(std::forward<AlarmIdentifierT>(value));
    return *this;
  }
 
 
  inline InsufficientDataHealthStatus GetInsufficientDataHealthStatus() const { return m_insufficientDataHealthStatus; }
  inline bool InsufficientDataHealthStatusHasBeenSet() const { return m_insufficientDataHealthStatusHasBeenSet; }
  inline void SetInsufficientDataHealthStatus(InsufficientDataHealthStatus value) {
    m_insufficientDataHealthStatusHasBeenSet = true;
    m_insufficientDataHealthStatus = value;
  }
  inline UpdateHealthCheckRequest& WithInsufficientDataHealthStatus(InsufficientDataHealthStatus value) {
    SetInsufficientDataHealthStatus(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ResettableElementName>& GetResetElements() const { return m_resetElements; }
  inline bool ResetElementsHasBeenSet() const { return m_resetElementsHasBeenSet; }
  template <typename ResetElementsT = Aws::Vector<ResettableElementName>>
  void SetResetElements(ResetElementsT&& value) {
    m_resetElementsHasBeenSet = true;
    m_resetElements = std::forward<ResetElementsT>(value);
  }
  template <typename ResetElementsT = Aws::Vector<ResettableElementName>>
  UpdateHealthCheckRequest& WithResetElements(ResetElementsT&& value) {
    SetResetElements(std::forward<ResetElementsT>(value));
    return *this;
  }
  inline UpdateHealthCheckRequest& AddResetElements(ResettableElementName value) {
    m_resetElementsHasBeenSet = true;
    m_resetElements.push_back(value);
    return *this;
  }
 private:
  Aws::String m_healthCheckId;
  bool m_healthCheckIdHasBeenSet = false;
 
  long long m_healthCheckVersion{0};
  bool m_healthCheckVersionHasBeenSet = false;
 
  Aws::String m_iPAddress;
  bool m_iPAddressHasBeenSet = false;
 
  int m_port{0};
  bool m_portHasBeenSet = false;
 
  Aws::String m_resourcePath;
  bool m_resourcePathHasBeenSet = false;
 
  Aws::String m_fullyQualifiedDomainName;
  bool m_fullyQualifiedDomainNameHasBeenSet = false;
 
  Aws::String m_searchString;
  bool m_searchStringHasBeenSet = false;
 
  int m_failureThreshold{0};
  bool m_failureThresholdHasBeenSet = false;
 
  bool m_inverted{false};
  bool m_invertedHasBeenSet = false;
 
  bool m_disabled{false};
  bool m_disabledHasBeenSet = false;
 
  int m_healthThreshold{0};
  bool m_healthThresholdHasBeenSet = false;
 
  Aws::Vector<Aws::String> m_childHealthChecks;
  bool m_childHealthChecksHasBeenSet = false;
 
  bool m_enableSNI{false};
  bool m_enableSNIHasBeenSet = false;
 
  Aws::Vector<HealthCheckRegion> m_regions;
  bool m_regionsHasBeenSet = false;
 
  AlarmIdentifier m_alarmIdentifier;
  bool m_alarmIdentifierHasBeenSet = false;
 
  InsufficientDataHealthStatus m_insufficientDataHealthStatus{InsufficientDataHealthStatus::NOT_SET};
  bool m_insufficientDataHealthStatusHasBeenSet = false;
 
  Aws::Vector<ResettableElementName> m_resetElements;
  bool m_resetElementsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Route53
}  // namespace Aws