UpdateCanaryRequest.h

 
#pragma once
#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/AddReplicaLocationInput.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/VisualReferenceInput.h>
#include <aws/synthetics/model/VpcConfigInput.h>
 
#include <utility>
 
namespace Aws {
namespace Synthetics {
namespace Model {
 
class UpdateCanaryRequest : public SyntheticsRequest {
 public:
  AWS_SYNTHETICS_API UpdateCanaryRequest() = 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 "UpdateCanary"; }
 
  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>
  UpdateCanaryRequest& 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>
  UpdateCanaryRequest& WithCode(CodeT&& value) {
    SetCode(std::forward<CodeT>(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>
  UpdateCanaryRequest& WithExecutionRoleArn(ExecutionRoleArnT&& value) {
    SetExecutionRoleArn(std::forward<ExecutionRoleArnT>(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>
  UpdateCanaryRequest& WithRuntimeVersion(RuntimeVersionT&& value) {
    SetRuntimeVersion(std::forward<RuntimeVersionT>(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>
  UpdateCanaryRequest& 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>
  UpdateCanaryRequest& 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 UpdateCanaryRequest& 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 UpdateCanaryRequest& WithFailureRetentionPeriodInDays(int value) {
    SetFailureRetentionPeriodInDays(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>
  UpdateCanaryRequest& WithVpcConfig(VpcConfigT&& value) {
    SetVpcConfig(std::forward<VpcConfigT>(value));
    return *this;
  }
 
 
  inline const VisualReferenceInput& GetVisualReference() const { return m_visualReference; }
  inline bool VisualReferenceHasBeenSet() const { return m_visualReferenceHasBeenSet; }
  template <typename VisualReferenceT = VisualReferenceInput>
  void SetVisualReference(VisualReferenceT&& value) {
    m_visualReferenceHasBeenSet = true;
    m_visualReference = std::forward<VisualReferenceT>(value);
  }
  template <typename VisualReferenceT = VisualReferenceInput>
  UpdateCanaryRequest& WithVisualReference(VisualReferenceT&& value) {
    SetVisualReference(std::forward<VisualReferenceT>(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>
  UpdateCanaryRequest& WithArtifactS3Location(ArtifactS3LocationT&& value) {
    SetArtifactS3Location(std::forward<ArtifactS3LocationT>(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>
  UpdateCanaryRequest& WithArtifactConfig(ArtifactConfigT&& value) {
    SetArtifactConfig(std::forward<ArtifactConfigT>(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 UpdateCanaryRequest& WithProvisionedResourceCleanup(ProvisionedResourceCleanupSetting value) {
    SetProvisionedResourceCleanup(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDryRunId() const { return m_dryRunId; }
  inline bool DryRunIdHasBeenSet() const { return m_dryRunIdHasBeenSet; }
  template <typename DryRunIdT = Aws::String>
  void SetDryRunId(DryRunIdT&& value) {
    m_dryRunIdHasBeenSet = true;
    m_dryRunId = std::forward<DryRunIdT>(value);
  }
  template <typename DryRunIdT = Aws::String>
  UpdateCanaryRequest& WithDryRunId(DryRunIdT&& value) {
    SetDryRunId(std::forward<DryRunIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<VisualReferenceInput>& GetVisualReferences() const { return m_visualReferences; }
  inline bool VisualReferencesHasBeenSet() const { return m_visualReferencesHasBeenSet; }
  template <typename VisualReferencesT = Aws::Vector<VisualReferenceInput>>
  void SetVisualReferences(VisualReferencesT&& value) {
    m_visualReferencesHasBeenSet = true;
    m_visualReferences = std::forward<VisualReferencesT>(value);
  }
  template <typename VisualReferencesT = Aws::Vector<VisualReferenceInput>>
  UpdateCanaryRequest& WithVisualReferences(VisualReferencesT&& value) {
    SetVisualReferences(std::forward<VisualReferencesT>(value));
    return *this;
  }
  template <typename VisualReferencesT = VisualReferenceInput>
  UpdateCanaryRequest& AddVisualReferences(VisualReferencesT&& value) {
    m_visualReferencesHasBeenSet = true;
    m_visualReferences.emplace_back(std::forward<VisualReferencesT>(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>>
  UpdateCanaryRequest& WithBrowserConfigs(BrowserConfigsT&& value) {
    SetBrowserConfigs(std::forward<BrowserConfigsT>(value));
    return *this;
  }
  template <typename BrowserConfigsT = BrowserConfig>
  UpdateCanaryRequest& AddBrowserConfigs(BrowserConfigsT&& value) {
    m_browserConfigsHasBeenSet = true;
    m_browserConfigs.emplace_back(std::forward<BrowserConfigsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AddReplicaLocationInput>& GetAddReplicaLocations() const { return m_addReplicaLocations; }
  inline bool AddReplicaLocationsHasBeenSet() const { return m_addReplicaLocationsHasBeenSet; }
  template <typename AddReplicaLocationsT = Aws::Vector<AddReplicaLocationInput>>
  void SetAddReplicaLocations(AddReplicaLocationsT&& value) {
    m_addReplicaLocationsHasBeenSet = true;
    m_addReplicaLocations = std::forward<AddReplicaLocationsT>(value);
  }
  template <typename AddReplicaLocationsT = Aws::Vector<AddReplicaLocationInput>>
  UpdateCanaryRequest& WithAddReplicaLocations(AddReplicaLocationsT&& value) {
    SetAddReplicaLocations(std::forward<AddReplicaLocationsT>(value));
    return *this;
  }
  template <typename AddReplicaLocationsT = AddReplicaLocationInput>
  UpdateCanaryRequest& AddAddReplicaLocations(AddReplicaLocationsT&& value) {
    m_addReplicaLocationsHasBeenSet = true;
    m_addReplicaLocations.emplace_back(std::forward<AddReplicaLocationsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetRemoveReplicaLocations() const { return m_removeReplicaLocations; }
  inline bool RemoveReplicaLocationsHasBeenSet() const { return m_removeReplicaLocationsHasBeenSet; }
  template <typename RemoveReplicaLocationsT = Aws::Vector<Aws::String>>
  void SetRemoveReplicaLocations(RemoveReplicaLocationsT&& value) {
    m_removeReplicaLocationsHasBeenSet = true;
    m_removeReplicaLocations = std::forward<RemoveReplicaLocationsT>(value);
  }
  template <typename RemoveReplicaLocationsT = Aws::Vector<Aws::String>>
  UpdateCanaryRequest& WithRemoveReplicaLocations(RemoveReplicaLocationsT&& value) {
    SetRemoveReplicaLocations(std::forward<RemoveReplicaLocationsT>(value));
    return *this;
  }
  template <typename RemoveReplicaLocationsT = Aws::String>
  UpdateCanaryRequest& AddRemoveReplicaLocations(RemoveReplicaLocationsT&& value) {
    m_removeReplicaLocationsHasBeenSet = true;
    m_removeReplicaLocations.emplace_back(std::forward<RemoveReplicaLocationsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKmsKeyArn() const { return m_kmsKeyArn; }
  inline bool KmsKeyArnHasBeenSet() const { return m_kmsKeyArnHasBeenSet; }
  template <typename KmsKeyArnT = Aws::String>
  void SetKmsKeyArn(KmsKeyArnT&& value) {
    m_kmsKeyArnHasBeenSet = true;
    m_kmsKeyArn = std::forward<KmsKeyArnT>(value);
  }
  template <typename KmsKeyArnT = Aws::String>
  UpdateCanaryRequest& WithKmsKeyArn(KmsKeyArnT&& value) {
    SetKmsKeyArn(std::forward<KmsKeyArnT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  CanaryCodeInput m_code;
 
  Aws::String m_executionRoleArn;
 
  Aws::String m_runtimeVersion;
 
  CanaryScheduleInput m_schedule;
 
  CanaryRunConfigInput m_runConfig;
 
  int m_successRetentionPeriodInDays{0};
 
  int m_failureRetentionPeriodInDays{0};
 
  VpcConfigInput m_vpcConfig;
 
  VisualReferenceInput m_visualReference;
 
  Aws::String m_artifactS3Location;
 
  ArtifactConfigInput m_artifactConfig;
 
  ProvisionedResourceCleanupSetting m_provisionedResourceCleanup{ProvisionedResourceCleanupSetting::NOT_SET};
 
  Aws::String m_dryRunId;
 
  Aws::Vector<VisualReferenceInput> m_visualReferences;
 
  Aws::Vector<BrowserConfig> m_browserConfigs;
 
  Aws::Vector<AddReplicaLocationInput> m_addReplicaLocations;
 
  Aws::Vector<Aws::String> m_removeReplicaLocations;
 
  Aws::String m_kmsKeyArn;
  bool m_nameHasBeenSet = false;
  bool m_codeHasBeenSet = false;
  bool m_executionRoleArnHasBeenSet = false;
  bool m_runtimeVersionHasBeenSet = false;
  bool m_scheduleHasBeenSet = false;
  bool m_runConfigHasBeenSet = false;
  bool m_successRetentionPeriodInDaysHasBeenSet = false;
  bool m_failureRetentionPeriodInDaysHasBeenSet = false;
  bool m_vpcConfigHasBeenSet = false;
  bool m_visualReferenceHasBeenSet = false;
  bool m_artifactS3LocationHasBeenSet = false;
  bool m_artifactConfigHasBeenSet = false;
  bool m_provisionedResourceCleanupHasBeenSet = false;
  bool m_dryRunIdHasBeenSet = false;
  bool m_visualReferencesHasBeenSet = false;
  bool m_browserConfigsHasBeenSet = false;
  bool m_addReplicaLocationsHasBeenSet = false;
  bool m_removeReplicaLocationsHasBeenSet = false;
  bool m_kmsKeyArnHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Synthetics
}  // namespace Aws