CreateDistributionRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/lightsail/LightsailRequest.h>
#include <aws/lightsail/Lightsail_EXPORTS.h>
#include <aws/lightsail/model/CacheBehavior.h>
#include <aws/lightsail/model/CacheBehaviorPerPath.h>
#include <aws/lightsail/model/CacheSettings.h>
#include <aws/lightsail/model/InputOrigin.h>
#include <aws/lightsail/model/IpAddressType.h>
#include <aws/lightsail/model/Tag.h>
#include <aws/lightsail/model/ViewerMinimumTlsProtocolVersionEnum.h>
 
#include <utility>
 
namespace Aws {
namespace Lightsail {
namespace Model {
 
class CreateDistributionRequest : public LightsailRequest {
 public:
  AWS_LIGHTSAIL_API CreateDistributionRequest() = 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 "CreateDistribution"; }
 
  AWS_LIGHTSAIL_API Aws::String SerializePayload() const override;
 
  AWS_LIGHTSAIL_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline const Aws::String& GetDistributionName() const { return m_distributionName; }
  inline bool DistributionNameHasBeenSet() const { return m_distributionNameHasBeenSet; }
  template <typename DistributionNameT = Aws::String>
  void SetDistributionName(DistributionNameT&& value) {
    m_distributionNameHasBeenSet = true;
    m_distributionName = std::forward<DistributionNameT>(value);
  }
  template <typename DistributionNameT = Aws::String>
  CreateDistributionRequest& WithDistributionName(DistributionNameT&& value) {
    SetDistributionName(std::forward<DistributionNameT>(value));
    return *this;
  }
 
 
  inline const InputOrigin& GetOrigin() const { return m_origin; }
  inline bool OriginHasBeenSet() const { return m_originHasBeenSet; }
  template <typename OriginT = InputOrigin>
  void SetOrigin(OriginT&& value) {
    m_originHasBeenSet = true;
    m_origin = std::forward<OriginT>(value);
  }
  template <typename OriginT = InputOrigin>
  CreateDistributionRequest& WithOrigin(OriginT&& value) {
    SetOrigin(std::forward<OriginT>(value));
    return *this;
  }
 
 
  inline const CacheBehavior& GetDefaultCacheBehavior() const { return m_defaultCacheBehavior; }
  inline bool DefaultCacheBehaviorHasBeenSet() const { return m_defaultCacheBehaviorHasBeenSet; }
  template <typename DefaultCacheBehaviorT = CacheBehavior>
  void SetDefaultCacheBehavior(DefaultCacheBehaviorT&& value) {
    m_defaultCacheBehaviorHasBeenSet = true;
    m_defaultCacheBehavior = std::forward<DefaultCacheBehaviorT>(value);
  }
  template <typename DefaultCacheBehaviorT = CacheBehavior>
  CreateDistributionRequest& WithDefaultCacheBehavior(DefaultCacheBehaviorT&& value) {
    SetDefaultCacheBehavior(std::forward<DefaultCacheBehaviorT>(value));
    return *this;
  }
 
 
  inline const CacheSettings& GetCacheBehaviorSettings() const { return m_cacheBehaviorSettings; }
  inline bool CacheBehaviorSettingsHasBeenSet() const { return m_cacheBehaviorSettingsHasBeenSet; }
  template <typename CacheBehaviorSettingsT = CacheSettings>
  void SetCacheBehaviorSettings(CacheBehaviorSettingsT&& value) {
    m_cacheBehaviorSettingsHasBeenSet = true;
    m_cacheBehaviorSettings = std::forward<CacheBehaviorSettingsT>(value);
  }
  template <typename CacheBehaviorSettingsT = CacheSettings>
  CreateDistributionRequest& WithCacheBehaviorSettings(CacheBehaviorSettingsT&& value) {
    SetCacheBehaviorSettings(std::forward<CacheBehaviorSettingsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CacheBehaviorPerPath>& GetCacheBehaviors() const { return m_cacheBehaviors; }
  inline bool CacheBehaviorsHasBeenSet() const { return m_cacheBehaviorsHasBeenSet; }
  template <typename CacheBehaviorsT = Aws::Vector<CacheBehaviorPerPath>>
  void SetCacheBehaviors(CacheBehaviorsT&& value) {
    m_cacheBehaviorsHasBeenSet = true;
    m_cacheBehaviors = std::forward<CacheBehaviorsT>(value);
  }
  template <typename CacheBehaviorsT = Aws::Vector<CacheBehaviorPerPath>>
  CreateDistributionRequest& WithCacheBehaviors(CacheBehaviorsT&& value) {
    SetCacheBehaviors(std::forward<CacheBehaviorsT>(value));
    return *this;
  }
  template <typename CacheBehaviorsT = CacheBehaviorPerPath>
  CreateDistributionRequest& AddCacheBehaviors(CacheBehaviorsT&& value) {
    m_cacheBehaviorsHasBeenSet = true;
    m_cacheBehaviors.emplace_back(std::forward<CacheBehaviorsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBundleId() const { return m_bundleId; }
  inline bool BundleIdHasBeenSet() const { return m_bundleIdHasBeenSet; }
  template <typename BundleIdT = Aws::String>
  void SetBundleId(BundleIdT&& value) {
    m_bundleIdHasBeenSet = true;
    m_bundleId = std::forward<BundleIdT>(value);
  }
  template <typename BundleIdT = Aws::String>
  CreateDistributionRequest& WithBundleId(BundleIdT&& value) {
    SetBundleId(std::forward<BundleIdT>(value));
    return *this;
  }
 
 
  inline IpAddressType GetIpAddressType() const { return m_ipAddressType; }
  inline bool IpAddressTypeHasBeenSet() const { return m_ipAddressTypeHasBeenSet; }
  inline void SetIpAddressType(IpAddressType value) {
    m_ipAddressTypeHasBeenSet = true;
    m_ipAddressType = value;
  }
  inline CreateDistributionRequest& WithIpAddressType(IpAddressType value) {
    SetIpAddressType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  CreateDistributionRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CreateDistributionRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCertificateName() const { return m_certificateName; }
  inline bool CertificateNameHasBeenSet() const { return m_certificateNameHasBeenSet; }
  template <typename CertificateNameT = Aws::String>
  void SetCertificateName(CertificateNameT&& value) {
    m_certificateNameHasBeenSet = true;
    m_certificateName = std::forward<CertificateNameT>(value);
  }
  template <typename CertificateNameT = Aws::String>
  CreateDistributionRequest& WithCertificateName(CertificateNameT&& value) {
    SetCertificateName(std::forward<CertificateNameT>(value));
    return *this;
  }
 
 
  inline ViewerMinimumTlsProtocolVersionEnum GetViewerMinimumTlsProtocolVersion() const { return m_viewerMinimumTlsProtocolVersion; }
  inline bool ViewerMinimumTlsProtocolVersionHasBeenSet() const { return m_viewerMinimumTlsProtocolVersionHasBeenSet; }
  inline void SetViewerMinimumTlsProtocolVersion(ViewerMinimumTlsProtocolVersionEnum value) {
    m_viewerMinimumTlsProtocolVersionHasBeenSet = true;
    m_viewerMinimumTlsProtocolVersion = value;
  }
  inline CreateDistributionRequest& WithViewerMinimumTlsProtocolVersion(ViewerMinimumTlsProtocolVersionEnum value) {
    SetViewerMinimumTlsProtocolVersion(value);
    return *this;
  }
 private:
  Aws::String m_distributionName;
 
  InputOrigin m_origin;
 
  CacheBehavior m_defaultCacheBehavior;
 
  CacheSettings m_cacheBehaviorSettings;
 
  Aws::Vector<CacheBehaviorPerPath> m_cacheBehaviors;
 
  Aws::String m_bundleId;
 
  IpAddressType m_ipAddressType{IpAddressType::NOT_SET};
 
  Aws::Vector<Tag> m_tags;
 
  Aws::String m_certificateName;
 
  ViewerMinimumTlsProtocolVersionEnum m_viewerMinimumTlsProtocolVersion{ViewerMinimumTlsProtocolVersionEnum::NOT_SET};
  bool m_distributionNameHasBeenSet = false;
  bool m_originHasBeenSet = false;
  bool m_defaultCacheBehaviorHasBeenSet = false;
  bool m_cacheBehaviorSettingsHasBeenSet = false;
  bool m_cacheBehaviorsHasBeenSet = false;
  bool m_bundleIdHasBeenSet = false;
  bool m_ipAddressTypeHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_certificateNameHasBeenSet = false;
  bool m_viewerMinimumTlsProtocolVersionHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Lightsail
}  // namespace Aws