GetDomainNameResult.h

 
#pragma once
#include <aws/apigateway/APIGateway_EXPORTS.h>
#include <aws/apigateway/model/DomainNameStatus.h>
#include <aws/apigateway/model/EndpointAccessMode.h>
#include <aws/apigateway/model/EndpointConfiguration.h>
#include <aws/apigateway/model/MutualTlsAuthentication.h>
#include <aws/apigateway/model/RoutingMode.h>
#include <aws/apigateway/model/SecurityPolicy.h>
#include <aws/core/http/HttpResponse.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace APIGateway {
namespace Model {
class GetDomainNameResult {
 public:
  AWS_APIGATEWAY_API GetDomainNameResult() = default;
  AWS_APIGATEWAY_API GetDomainNameResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_APIGATEWAY_API GetDomainNameResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetDomainName() const { return m_domainName; }
  template <typename DomainNameT = Aws::String>
  void SetDomainName(DomainNameT&& value) {
    m_domainNameHasBeenSet = true;
    m_domainName = std::forward<DomainNameT>(value);
  }
  template <typename DomainNameT = Aws::String>
  GetDomainNameResult& WithDomainName(DomainNameT&& value) {
    SetDomainName(std::forward<DomainNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDomainNameId() const { return m_domainNameId; }
  template <typename DomainNameIdT = Aws::String>
  void SetDomainNameId(DomainNameIdT&& value) {
    m_domainNameIdHasBeenSet = true;
    m_domainNameId = std::forward<DomainNameIdT>(value);
  }
  template <typename DomainNameIdT = Aws::String>
  GetDomainNameResult& WithDomainNameId(DomainNameIdT&& value) {
    SetDomainNameId(std::forward<DomainNameIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDomainNameArn() const { return m_domainNameArn; }
  template <typename DomainNameArnT = Aws::String>
  void SetDomainNameArn(DomainNameArnT&& value) {
    m_domainNameArnHasBeenSet = true;
    m_domainNameArn = std::forward<DomainNameArnT>(value);
  }
  template <typename DomainNameArnT = Aws::String>
  GetDomainNameResult& WithDomainNameArn(DomainNameArnT&& value) {
    SetDomainNameArn(std::forward<DomainNameArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCertificateName() const { return m_certificateName; }
  template <typename CertificateNameT = Aws::String>
  void SetCertificateName(CertificateNameT&& value) {
    m_certificateNameHasBeenSet = true;
    m_certificateName = std::forward<CertificateNameT>(value);
  }
  template <typename CertificateNameT = Aws::String>
  GetDomainNameResult& WithCertificateName(CertificateNameT&& value) {
    SetCertificateName(std::forward<CertificateNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCertificateArn() const { return m_certificateArn; }
  template <typename CertificateArnT = Aws::String>
  void SetCertificateArn(CertificateArnT&& value) {
    m_certificateArnHasBeenSet = true;
    m_certificateArn = std::forward<CertificateArnT>(value);
  }
  template <typename CertificateArnT = Aws::String>
  GetDomainNameResult& WithCertificateArn(CertificateArnT&& value) {
    SetCertificateArn(std::forward<CertificateArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCertificateUploadDate() const { return m_certificateUploadDate; }
  template <typename CertificateUploadDateT = Aws::Utils::DateTime>
  void SetCertificateUploadDate(CertificateUploadDateT&& value) {
    m_certificateUploadDateHasBeenSet = true;
    m_certificateUploadDate = std::forward<CertificateUploadDateT>(value);
  }
  template <typename CertificateUploadDateT = Aws::Utils::DateTime>
  GetDomainNameResult& WithCertificateUploadDate(CertificateUploadDateT&& value) {
    SetCertificateUploadDate(std::forward<CertificateUploadDateT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRegionalDomainName() const { return m_regionalDomainName; }
  template <typename RegionalDomainNameT = Aws::String>
  void SetRegionalDomainName(RegionalDomainNameT&& value) {
    m_regionalDomainNameHasBeenSet = true;
    m_regionalDomainName = std::forward<RegionalDomainNameT>(value);
  }
  template <typename RegionalDomainNameT = Aws::String>
  GetDomainNameResult& WithRegionalDomainName(RegionalDomainNameT&& value) {
    SetRegionalDomainName(std::forward<RegionalDomainNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRegionalHostedZoneId() const { return m_regionalHostedZoneId; }
  template <typename RegionalHostedZoneIdT = Aws::String>
  void SetRegionalHostedZoneId(RegionalHostedZoneIdT&& value) {
    m_regionalHostedZoneIdHasBeenSet = true;
    m_regionalHostedZoneId = std::forward<RegionalHostedZoneIdT>(value);
  }
  template <typename RegionalHostedZoneIdT = Aws::String>
  GetDomainNameResult& WithRegionalHostedZoneId(RegionalHostedZoneIdT&& value) {
    SetRegionalHostedZoneId(std::forward<RegionalHostedZoneIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRegionalCertificateName() const { return m_regionalCertificateName; }
  template <typename RegionalCertificateNameT = Aws::String>
  void SetRegionalCertificateName(RegionalCertificateNameT&& value) {
    m_regionalCertificateNameHasBeenSet = true;
    m_regionalCertificateName = std::forward<RegionalCertificateNameT>(value);
  }
  template <typename RegionalCertificateNameT = Aws::String>
  GetDomainNameResult& WithRegionalCertificateName(RegionalCertificateNameT&& value) {
    SetRegionalCertificateName(std::forward<RegionalCertificateNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRegionalCertificateArn() const { return m_regionalCertificateArn; }
  template <typename RegionalCertificateArnT = Aws::String>
  void SetRegionalCertificateArn(RegionalCertificateArnT&& value) {
    m_regionalCertificateArnHasBeenSet = true;
    m_regionalCertificateArn = std::forward<RegionalCertificateArnT>(value);
  }
  template <typename RegionalCertificateArnT = Aws::String>
  GetDomainNameResult& WithRegionalCertificateArn(RegionalCertificateArnT&& value) {
    SetRegionalCertificateArn(std::forward<RegionalCertificateArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDistributionDomainName() const { return m_distributionDomainName; }
  template <typename DistributionDomainNameT = Aws::String>
  void SetDistributionDomainName(DistributionDomainNameT&& value) {
    m_distributionDomainNameHasBeenSet = true;
    m_distributionDomainName = std::forward<DistributionDomainNameT>(value);
  }
  template <typename DistributionDomainNameT = Aws::String>
  GetDomainNameResult& WithDistributionDomainName(DistributionDomainNameT&& value) {
    SetDistributionDomainName(std::forward<DistributionDomainNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDistributionHostedZoneId() const { return m_distributionHostedZoneId; }
  template <typename DistributionHostedZoneIdT = Aws::String>
  void SetDistributionHostedZoneId(DistributionHostedZoneIdT&& value) {
    m_distributionHostedZoneIdHasBeenSet = true;
    m_distributionHostedZoneId = std::forward<DistributionHostedZoneIdT>(value);
  }
  template <typename DistributionHostedZoneIdT = Aws::String>
  GetDomainNameResult& WithDistributionHostedZoneId(DistributionHostedZoneIdT&& value) {
    SetDistributionHostedZoneId(std::forward<DistributionHostedZoneIdT>(value));
    return *this;
  }
 
 
  inline const EndpointConfiguration& GetEndpointConfiguration() const { return m_endpointConfiguration; }
  template <typename EndpointConfigurationT = EndpointConfiguration>
  void SetEndpointConfiguration(EndpointConfigurationT&& value) {
    m_endpointConfigurationHasBeenSet = true;
    m_endpointConfiguration = std::forward<EndpointConfigurationT>(value);
  }
  template <typename EndpointConfigurationT = EndpointConfiguration>
  GetDomainNameResult& WithEndpointConfiguration(EndpointConfigurationT&& value) {
    SetEndpointConfiguration(std::forward<EndpointConfigurationT>(value));
    return *this;
  }
 
 
  inline DomainNameStatus GetDomainNameStatus() const { return m_domainNameStatus; }
  inline void SetDomainNameStatus(DomainNameStatus value) {
    m_domainNameStatusHasBeenSet = true;
    m_domainNameStatus = value;
  }
  inline GetDomainNameResult& WithDomainNameStatus(DomainNameStatus value) {
    SetDomainNameStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDomainNameStatusMessage() const { return m_domainNameStatusMessage; }
  template <typename DomainNameStatusMessageT = Aws::String>
  void SetDomainNameStatusMessage(DomainNameStatusMessageT&& value) {
    m_domainNameStatusMessageHasBeenSet = true;
    m_domainNameStatusMessage = std::forward<DomainNameStatusMessageT>(value);
  }
  template <typename DomainNameStatusMessageT = Aws::String>
  GetDomainNameResult& WithDomainNameStatusMessage(DomainNameStatusMessageT&& value) {
    SetDomainNameStatusMessage(std::forward<DomainNameStatusMessageT>(value));
    return *this;
  }
 
 
  inline SecurityPolicy GetSecurityPolicy() const { return m_securityPolicy; }
  inline void SetSecurityPolicy(SecurityPolicy value) {
    m_securityPolicyHasBeenSet = true;
    m_securityPolicy = value;
  }
  inline GetDomainNameResult& WithSecurityPolicy(SecurityPolicy value) {
    SetSecurityPolicy(value);
    return *this;
  }
 
 
  inline EndpointAccessMode GetEndpointAccessMode() const { return m_endpointAccessMode; }
  inline void SetEndpointAccessMode(EndpointAccessMode value) {
    m_endpointAccessModeHasBeenSet = true;
    m_endpointAccessMode = value;
  }
  inline GetDomainNameResult& WithEndpointAccessMode(EndpointAccessMode value) {
    SetEndpointAccessMode(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  GetDomainNameResult& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  GetDomainNameResult& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const MutualTlsAuthentication& GetMutualTlsAuthentication() const { return m_mutualTlsAuthentication; }
  template <typename MutualTlsAuthenticationT = MutualTlsAuthentication>
  void SetMutualTlsAuthentication(MutualTlsAuthenticationT&& value) {
    m_mutualTlsAuthenticationHasBeenSet = true;
    m_mutualTlsAuthentication = std::forward<MutualTlsAuthenticationT>(value);
  }
  template <typename MutualTlsAuthenticationT = MutualTlsAuthentication>
  GetDomainNameResult& WithMutualTlsAuthentication(MutualTlsAuthenticationT&& value) {
    SetMutualTlsAuthentication(std::forward<MutualTlsAuthenticationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOwnershipVerificationCertificateArn() const { return m_ownershipVerificationCertificateArn; }
  template <typename OwnershipVerificationCertificateArnT = Aws::String>
  void SetOwnershipVerificationCertificateArn(OwnershipVerificationCertificateArnT&& value) {
    m_ownershipVerificationCertificateArnHasBeenSet = true;
    m_ownershipVerificationCertificateArn = std::forward<OwnershipVerificationCertificateArnT>(value);
  }
  template <typename OwnershipVerificationCertificateArnT = Aws::String>
  GetDomainNameResult& WithOwnershipVerificationCertificateArn(OwnershipVerificationCertificateArnT&& value) {
    SetOwnershipVerificationCertificateArn(std::forward<OwnershipVerificationCertificateArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetManagementPolicy() const { return m_managementPolicy; }
  template <typename ManagementPolicyT = Aws::String>
  void SetManagementPolicy(ManagementPolicyT&& value) {
    m_managementPolicyHasBeenSet = true;
    m_managementPolicy = std::forward<ManagementPolicyT>(value);
  }
  template <typename ManagementPolicyT = Aws::String>
  GetDomainNameResult& WithManagementPolicy(ManagementPolicyT&& value) {
    SetManagementPolicy(std::forward<ManagementPolicyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPolicy() const { return m_policy; }
  template <typename PolicyT = Aws::String>
  void SetPolicy(PolicyT&& value) {
    m_policyHasBeenSet = true;
    m_policy = std::forward<PolicyT>(value);
  }
  template <typename PolicyT = Aws::String>
  GetDomainNameResult& WithPolicy(PolicyT&& value) {
    SetPolicy(std::forward<PolicyT>(value));
    return *this;
  }
 
 
  inline RoutingMode GetRoutingMode() const { return m_routingMode; }
  inline void SetRoutingMode(RoutingMode value) {
    m_routingModeHasBeenSet = true;
    m_routingMode = value;
  }
  inline GetDomainNameResult& WithRoutingMode(RoutingMode value) {
    SetRoutingMode(value);
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  GetDomainNameResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
  inline Aws::Http::HttpResponseCode GetHttpResponseCode() const { return m_HttpResponseCode; }
 
 private:
  Aws::String m_domainName;
 
  Aws::String m_domainNameId;
 
  Aws::String m_domainNameArn;
 
  Aws::String m_certificateName;
 
  Aws::String m_certificateArn;
 
  Aws::Utils::DateTime m_certificateUploadDate{};
 
  Aws::String m_regionalDomainName;
 
  Aws::String m_regionalHostedZoneId;
 
  Aws::String m_regionalCertificateName;
 
  Aws::String m_regionalCertificateArn;
 
  Aws::String m_distributionDomainName;
 
  Aws::String m_distributionHostedZoneId;
 
  EndpointConfiguration m_endpointConfiguration;
 
  DomainNameStatus m_domainNameStatus{DomainNameStatus::NOT_SET};
 
  Aws::String m_domainNameStatusMessage;
 
  SecurityPolicy m_securityPolicy{SecurityPolicy::NOT_SET};
 
  EndpointAccessMode m_endpointAccessMode{EndpointAccessMode::NOT_SET};
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  MutualTlsAuthentication m_mutualTlsAuthentication;
 
  Aws::String m_ownershipVerificationCertificateArn;
 
  Aws::String m_managementPolicy;
 
  Aws::String m_policy;
 
  RoutingMode m_routingMode{RoutingMode::NOT_SET};
 
  Aws::String m_requestId;
  Aws::Http::HttpResponseCode m_HttpResponseCode;
  bool m_domainNameHasBeenSet = false;
  bool m_domainNameIdHasBeenSet = false;
  bool m_domainNameArnHasBeenSet = false;
  bool m_certificateNameHasBeenSet = false;
  bool m_certificateArnHasBeenSet = false;
  bool m_certificateUploadDateHasBeenSet = false;
  bool m_regionalDomainNameHasBeenSet = false;
  bool m_regionalHostedZoneIdHasBeenSet = false;
  bool m_regionalCertificateNameHasBeenSet = false;
  bool m_regionalCertificateArnHasBeenSet = false;
  bool m_distributionDomainNameHasBeenSet = false;
  bool m_distributionHostedZoneIdHasBeenSet = false;
  bool m_endpointConfigurationHasBeenSet = false;
  bool m_domainNameStatusHasBeenSet = false;
  bool m_domainNameStatusMessageHasBeenSet = false;
  bool m_securityPolicyHasBeenSet = false;
  bool m_endpointAccessModeHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_mutualTlsAuthenticationHasBeenSet = false;
  bool m_ownershipVerificationCertificateArnHasBeenSet = false;
  bool m_managementPolicyHasBeenSet = false;
  bool m_policyHasBeenSet = false;
  bool m_routingModeHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace APIGateway
}  // namespace Aws