CreateCanaryRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/synthetics/SyntheticsRequest.h>
#include <aws/synthetics/Synthetics_EXPORTS.h>
#include <aws/synthetics/model/ArtifactConfigInput.h>
#include <aws/synthetics/model/BrowserConfig.h>
#include <aws/synthetics/model/CanaryCodeInput.h>
#include <aws/synthetics/model/CanaryRunConfigInput.h>
#include <aws/synthetics/model/CanaryScheduleInput.h>
#include <aws/synthetics/model/ProvisionedResourceCleanupSetting.h>
#include <aws/synthetics/model/ResourceToTag.h>
#include <aws/synthetics/model/VpcConfigInput.h>
 
#include <utility>
 
namespace Aws {
namespace Synthetics {
namespace Model {
 
class CreateCanaryRequest : public SyntheticsRequest {
 public:
  AWS_SYNTHETICS_API CreateCanaryRequest() = 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 "CreateCanary"; }
 
  AWS_SYNTHETICS_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  CreateCanaryRequest& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const CanaryCodeInput& GetCode() const { return m_code; }
  inline bool CodeHasBeenSet() const { return m_codeHasBeenSet; }
  template <typename CodeT = CanaryCodeInput>
  void SetCode(CodeT&& value) {
    m_codeHasBeenSet = true;
    m_code = std::forward<CodeT>(value);
  }
  template <typename CodeT = CanaryCodeInput>
  CreateCanaryRequest& WithCode(CodeT&& value) {
    SetCode(std::forward<CodeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetArtifactS3Location() const { return m_artifactS3Location; }
  inline bool ArtifactS3LocationHasBeenSet() const { return m_artifactS3LocationHasBeenSet; }
  template <typename ArtifactS3LocationT = Aws::String>
  void SetArtifactS3Location(ArtifactS3LocationT&& value) {
    m_artifactS3LocationHasBeenSet = true;
    m_artifactS3Location = std::forward<ArtifactS3LocationT>(value);
  }
  template <typename ArtifactS3LocationT = Aws::String>
  CreateCanaryRequest& WithArtifactS3Location(ArtifactS3LocationT&& value) {
    SetArtifactS3Location(std::forward<ArtifactS3LocationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecutionRoleArn() const { return m_executionRoleArn; }
  inline bool ExecutionRoleArnHasBeenSet() const { return m_executionRoleArnHasBeenSet; }
  template <typename ExecutionRoleArnT = Aws::String>
  void SetExecutionRoleArn(ExecutionRoleArnT&& value) {
    m_executionRoleArnHasBeenSet = true;
    m_executionRoleArn = std::forward<ExecutionRoleArnT>(value);
  }
  template <typename ExecutionRoleArnT = Aws::String>
  CreateCanaryRequest& WithExecutionRoleArn(ExecutionRoleArnT&& value) {
    SetExecutionRoleArn(std::forward<ExecutionRoleArnT>(value));
    return *this;
  }
 
 
  inline const CanaryScheduleInput& GetSchedule() const { return m_schedule; }
  inline bool ScheduleHasBeenSet() const { return m_scheduleHasBeenSet; }
  template <typename ScheduleT = CanaryScheduleInput>
  void SetSchedule(ScheduleT&& value) {
    m_scheduleHasBeenSet = true;
    m_schedule = std::forward<ScheduleT>(value);
  }
  template <typename ScheduleT = CanaryScheduleInput>
  CreateCanaryRequest& WithSchedule(ScheduleT&& value) {
    SetSchedule(std::forward<ScheduleT>(value));
    return *this;
  }
 
 
  inline const CanaryRunConfigInput& GetRunConfig() const { return m_runConfig; }
  inline bool RunConfigHasBeenSet() const { return m_runConfigHasBeenSet; }
  template <typename RunConfigT = CanaryRunConfigInput>
  void SetRunConfig(RunConfigT&& value) {
    m_runConfigHasBeenSet = true;
    m_runConfig = std::forward<RunConfigT>(value);
  }
  template <typename RunConfigT = CanaryRunConfigInput>
  CreateCanaryRequest& WithRunConfig(RunConfigT&& value) {
    SetRunConfig(std::forward<RunConfigT>(value));
    return *this;
  }
 
 
  inline int GetSuccessRetentionPeriodInDays() const { return m_successRetentionPeriodInDays; }
  inline bool SuccessRetentionPeriodInDaysHasBeenSet() const { return m_successRetentionPeriodInDaysHasBeenSet; }
  inline void SetSuccessRetentionPeriodInDays(int value) {
    m_successRetentionPeriodInDaysHasBeenSet = true;
    m_successRetentionPeriodInDays = value;
  }
  inline CreateCanaryRequest& WithSuccessRetentionPeriodInDays(int value) {
    SetSuccessRetentionPeriodInDays(value);
    return *this;
  }
 
 
  inline int GetFailureRetentionPeriodInDays() const { return m_failureRetentionPeriodInDays; }
  inline bool FailureRetentionPeriodInDaysHasBeenSet() const { return m_failureRetentionPeriodInDaysHasBeenSet; }
  inline void SetFailureRetentionPeriodInDays(int value) {
    m_failureRetentionPeriodInDaysHasBeenSet = true;
    m_failureRetentionPeriodInDays = value;
  }
  inline CreateCanaryRequest& WithFailureRetentionPeriodInDays(int value) {
    SetFailureRetentionPeriodInDays(value);
    return *this;
  }
 
 
  inline const Aws::String& GetRuntimeVersion() const { return m_runtimeVersion; }
  inline bool RuntimeVersionHasBeenSet() const { return m_runtimeVersionHasBeenSet; }
  template <typename RuntimeVersionT = Aws::String>
  void SetRuntimeVersion(RuntimeVersionT&& value) {
    m_runtimeVersionHasBeenSet = true;
    m_runtimeVersion = std::forward<RuntimeVersionT>(value);
  }
  template <typename RuntimeVersionT = Aws::String>
  CreateCanaryRequest& WithRuntimeVersion(RuntimeVersionT&& value) {
    SetRuntimeVersion(std::forward<RuntimeVersionT>(value));
    return *this;
  }
 
 
  inline const VpcConfigInput& GetVpcConfig() const { return m_vpcConfig; }
  inline bool VpcConfigHasBeenSet() const { return m_vpcConfigHasBeenSet; }
  template <typename VpcConfigT = VpcConfigInput>
  void SetVpcConfig(VpcConfigT&& value) {
    m_vpcConfigHasBeenSet = true;
    m_vpcConfig = std::forward<VpcConfigT>(value);
  }
  template <typename VpcConfigT = VpcConfigInput>
  CreateCanaryRequest& WithVpcConfig(VpcConfigT&& value) {
    SetVpcConfig(std::forward<VpcConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ResourceToTag>& GetResourcesToReplicateTags() const { return m_resourcesToReplicateTags; }
  inline bool ResourcesToReplicateTagsHasBeenSet() const { return m_resourcesToReplicateTagsHasBeenSet; }
  template <typename ResourcesToReplicateTagsT = Aws::Vector<ResourceToTag>>
  void SetResourcesToReplicateTags(ResourcesToReplicateTagsT&& value) {
    m_resourcesToReplicateTagsHasBeenSet = true;
    m_resourcesToReplicateTags = std::forward<ResourcesToReplicateTagsT>(value);
  }
  template <typename ResourcesToReplicateTagsT = Aws::Vector<ResourceToTag>>
  CreateCanaryRequest& WithResourcesToReplicateTags(ResourcesToReplicateTagsT&& value) {
    SetResourcesToReplicateTags(std::forward<ResourcesToReplicateTagsT>(value));
    return *this;
  }
  inline CreateCanaryRequest& AddResourcesToReplicateTags(ResourceToTag value) {
    m_resourcesToReplicateTagsHasBeenSet = true;
    m_resourcesToReplicateTags.push_back(value);
    return *this;
  }
 
 
  inline ProvisionedResourceCleanupSetting GetProvisionedResourceCleanup() const { return m_provisionedResourceCleanup; }
  inline bool ProvisionedResourceCleanupHasBeenSet() const { return m_provisionedResourceCleanupHasBeenSet; }
  inline void SetProvisionedResourceCleanup(ProvisionedResourceCleanupSetting value) {
    m_provisionedResourceCleanupHasBeenSet = true;
    m_provisionedResourceCleanup = value;
  }
  inline CreateCanaryRequest& WithProvisionedResourceCleanup(ProvisionedResourceCleanupSetting value) {
    SetProvisionedResourceCleanup(value);
    return *this;
  }
 
 
  inline const Aws::Vector<BrowserConfig>& GetBrowserConfigs() const { return m_browserConfigs; }
  inline bool BrowserConfigsHasBeenSet() const { return m_browserConfigsHasBeenSet; }
  template <typename BrowserConfigsT = Aws::Vector<BrowserConfig>>
  void SetBrowserConfigs(BrowserConfigsT&& value) {
    m_browserConfigsHasBeenSet = true;
    m_browserConfigs = std::forward<BrowserConfigsT>(value);
  }
  template <typename BrowserConfigsT = Aws::Vector<BrowserConfig>>
  CreateCanaryRequest& WithBrowserConfigs(BrowserConfigsT&& value) {
    SetBrowserConfigs(std::forward<BrowserConfigsT>(value));
    return *this;
  }
  template <typename BrowserConfigsT = BrowserConfig>
  CreateCanaryRequest& AddBrowserConfigs(BrowserConfigsT&& value) {
    m_browserConfigsHasBeenSet = true;
    m_browserConfigs.emplace_back(std::forward<BrowserConfigsT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  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>>
  CreateCanaryRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  CreateCanaryRequest& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const ArtifactConfigInput& GetArtifactConfig() const { return m_artifactConfig; }
  inline bool ArtifactConfigHasBeenSet() const { return m_artifactConfigHasBeenSet; }
  template <typename ArtifactConfigT = ArtifactConfigInput>
  void SetArtifactConfig(ArtifactConfigT&& value) {
    m_artifactConfigHasBeenSet = true;
    m_artifactConfig = std::forward<ArtifactConfigT>(value);
  }
  template <typename ArtifactConfigT = ArtifactConfigInput>
  CreateCanaryRequest& WithArtifactConfig(ArtifactConfigT&& value) {
    SetArtifactConfig(std::forward<ArtifactConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  CanaryCodeInput m_code;
 
  Aws::String m_artifactS3Location;
 
  Aws::String m_executionRoleArn;
 
  CanaryScheduleInput m_schedule;
 
  CanaryRunConfigInput m_runConfig;
 
  int m_successRetentionPeriodInDays{0};
 
  int m_failureRetentionPeriodInDays{0};
 
  Aws::String m_runtimeVersion;
 
  VpcConfigInput m_vpcConfig;
 
  Aws::Vector<ResourceToTag> m_resourcesToReplicateTags;
 
  ProvisionedResourceCleanupSetting m_provisionedResourceCleanup{ProvisionedResourceCleanupSetting::NOT_SET};
 
  Aws::Vector<BrowserConfig> m_browserConfigs;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  ArtifactConfigInput m_artifactConfig;
  bool m_nameHasBeenSet = false;
  bool m_codeHasBeenSet = false;
  bool m_artifactS3LocationHasBeenSet = false;
  bool m_executionRoleArnHasBeenSet = false;
  bool m_scheduleHasBeenSet = false;
  bool m_runConfigHasBeenSet = false;
  bool m_successRetentionPeriodInDaysHasBeenSet = false;
  bool m_failureRetentionPeriodInDaysHasBeenSet = false;
  bool m_runtimeVersionHasBeenSet = false;
  bool m_vpcConfigHasBeenSet = false;
  bool m_resourcesToReplicateTagsHasBeenSet = false;
  bool m_provisionedResourceCleanupHasBeenSet = false;
  bool m_browserConfigsHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_artifactConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Synthetics
}  // namespace Aws