UpdateHealthCheckRequest.h

 
#pragma once
#include <aws/route53/Route53_EXPORTS.h>
#include <aws/route53/Route53Request.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/route53/model/AlarmIdentifier.h>
#include <aws/route53/model/InsufficientDataHealthStatus.h>
#include <aws/route53/model/HealthCheckRegion.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