Target.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/events/CloudWatchEvents_EXPORTS.h>
#include <aws/events/model/BatchParameters.h>
#include <aws/events/model/DeadLetterConfig.h>
#include <aws/events/model/EcsParameters.h>
#include <aws/events/model/HttpParameters.h>
#include <aws/events/model/InputTransformer.h>
#include <aws/events/model/KinesisParameters.h>
#include <aws/events/model/RedshiftDataParameters.h>
#include <aws/events/model/RetryPolicy.h>
#include <aws/events/model/RunCommandParameters.h>
#include <aws/events/model/SageMakerPipelineParameters.h>
#include <aws/events/model/SqsParameters.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CloudWatchEvents {
namespace Model {
 
class Target {
 public:
  AWS_CLOUDWATCHEVENTS_API Target() = default;
  AWS_CLOUDWATCHEVENTS_API Target(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLOUDWATCHEVENTS_API Target& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLOUDWATCHEVENTS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetId() const { return m_id; }
  inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
  template <typename IdT = Aws::String>
  void SetId(IdT&& value) {
    m_idHasBeenSet = true;
    m_id = std::forward<IdT>(value);
  }
  template <typename IdT = Aws::String>
  Target& WithId(IdT&& value) {
    SetId(std::forward<IdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetArn() const { return m_arn; }
  inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
  template <typename ArnT = Aws::String>
  void SetArn(ArnT&& value) {
    m_arnHasBeenSet = true;
    m_arn = std::forward<ArnT>(value);
  }
  template <typename ArnT = Aws::String>
  Target& WithArn(ArnT&& value) {
    SetArn(std::forward<ArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRoleArn() const { return m_roleArn; }
  inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
  template <typename RoleArnT = Aws::String>
  void SetRoleArn(RoleArnT&& value) {
    m_roleArnHasBeenSet = true;
    m_roleArn = std::forward<RoleArnT>(value);
  }
  template <typename RoleArnT = Aws::String>
  Target& WithRoleArn(RoleArnT&& value) {
    SetRoleArn(std::forward<RoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInput() const { return m_input; }
  inline bool InputHasBeenSet() const { return m_inputHasBeenSet; }
  template <typename InputT = Aws::String>
  void SetInput(InputT&& value) {
    m_inputHasBeenSet = true;
    m_input = std::forward<InputT>(value);
  }
  template <typename InputT = Aws::String>
  Target& WithInput(InputT&& value) {
    SetInput(std::forward<InputT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInputPath() const { return m_inputPath; }
  inline bool InputPathHasBeenSet() const { return m_inputPathHasBeenSet; }
  template <typename InputPathT = Aws::String>
  void SetInputPath(InputPathT&& value) {
    m_inputPathHasBeenSet = true;
    m_inputPath = std::forward<InputPathT>(value);
  }
  template <typename InputPathT = Aws::String>
  Target& WithInputPath(InputPathT&& value) {
    SetInputPath(std::forward<InputPathT>(value));
    return *this;
  }
 
 
  inline const InputTransformer& GetInputTransformer() const { return m_inputTransformer; }
  inline bool InputTransformerHasBeenSet() const { return m_inputTransformerHasBeenSet; }
  template <typename InputTransformerT = InputTransformer>
  void SetInputTransformer(InputTransformerT&& value) {
    m_inputTransformerHasBeenSet = true;
    m_inputTransformer = std::forward<InputTransformerT>(value);
  }
  template <typename InputTransformerT = InputTransformer>
  Target& WithInputTransformer(InputTransformerT&& value) {
    SetInputTransformer(std::forward<InputTransformerT>(value));
    return *this;
  }
 
 
  inline const KinesisParameters& GetKinesisParameters() const { return m_kinesisParameters; }
  inline bool KinesisParametersHasBeenSet() const { return m_kinesisParametersHasBeenSet; }
  template <typename KinesisParametersT = KinesisParameters>
  void SetKinesisParameters(KinesisParametersT&& value) {
    m_kinesisParametersHasBeenSet = true;
    m_kinesisParameters = std::forward<KinesisParametersT>(value);
  }
  template <typename KinesisParametersT = KinesisParameters>
  Target& WithKinesisParameters(KinesisParametersT&& value) {
    SetKinesisParameters(std::forward<KinesisParametersT>(value));
    return *this;
  }
 
 
  inline const RunCommandParameters& GetRunCommandParameters() const { return m_runCommandParameters; }
  inline bool RunCommandParametersHasBeenSet() const { return m_runCommandParametersHasBeenSet; }
  template <typename RunCommandParametersT = RunCommandParameters>
  void SetRunCommandParameters(RunCommandParametersT&& value) {
    m_runCommandParametersHasBeenSet = true;
    m_runCommandParameters = std::forward<RunCommandParametersT>(value);
  }
  template <typename RunCommandParametersT = RunCommandParameters>
  Target& WithRunCommandParameters(RunCommandParametersT&& value) {
    SetRunCommandParameters(std::forward<RunCommandParametersT>(value));
    return *this;
  }
 
 
  inline const EcsParameters& GetEcsParameters() const { return m_ecsParameters; }
  inline bool EcsParametersHasBeenSet() const { return m_ecsParametersHasBeenSet; }
  template <typename EcsParametersT = EcsParameters>
  void SetEcsParameters(EcsParametersT&& value) {
    m_ecsParametersHasBeenSet = true;
    m_ecsParameters = std::forward<EcsParametersT>(value);
  }
  template <typename EcsParametersT = EcsParameters>
  Target& WithEcsParameters(EcsParametersT&& value) {
    SetEcsParameters(std::forward<EcsParametersT>(value));
    return *this;
  }
 
 
  inline const BatchParameters& GetBatchParameters() const { return m_batchParameters; }
  inline bool BatchParametersHasBeenSet() const { return m_batchParametersHasBeenSet; }
  template <typename BatchParametersT = BatchParameters>
  void SetBatchParameters(BatchParametersT&& value) {
    m_batchParametersHasBeenSet = true;
    m_batchParameters = std::forward<BatchParametersT>(value);
  }
  template <typename BatchParametersT = BatchParameters>
  Target& WithBatchParameters(BatchParametersT&& value) {
    SetBatchParameters(std::forward<BatchParametersT>(value));
    return *this;
  }
 
 
  inline const SqsParameters& GetSqsParameters() const { return m_sqsParameters; }
  inline bool SqsParametersHasBeenSet() const { return m_sqsParametersHasBeenSet; }
  template <typename SqsParametersT = SqsParameters>
  void SetSqsParameters(SqsParametersT&& value) {
    m_sqsParametersHasBeenSet = true;
    m_sqsParameters = std::forward<SqsParametersT>(value);
  }
  template <typename SqsParametersT = SqsParameters>
  Target& WithSqsParameters(SqsParametersT&& value) {
    SetSqsParameters(std::forward<SqsParametersT>(value));
    return *this;
  }
 
 
  inline const HttpParameters& GetHttpParameters() const { return m_httpParameters; }
  inline bool HttpParametersHasBeenSet() const { return m_httpParametersHasBeenSet; }
  template <typename HttpParametersT = HttpParameters>
  void SetHttpParameters(HttpParametersT&& value) {
    m_httpParametersHasBeenSet = true;
    m_httpParameters = std::forward<HttpParametersT>(value);
  }
  template <typename HttpParametersT = HttpParameters>
  Target& WithHttpParameters(HttpParametersT&& value) {
    SetHttpParameters(std::forward<HttpParametersT>(value));
    return *this;
  }
 
 
  inline const RedshiftDataParameters& GetRedshiftDataParameters() const { return m_redshiftDataParameters; }
  inline bool RedshiftDataParametersHasBeenSet() const { return m_redshiftDataParametersHasBeenSet; }
  template <typename RedshiftDataParametersT = RedshiftDataParameters>
  void SetRedshiftDataParameters(RedshiftDataParametersT&& value) {
    m_redshiftDataParametersHasBeenSet = true;
    m_redshiftDataParameters = std::forward<RedshiftDataParametersT>(value);
  }
  template <typename RedshiftDataParametersT = RedshiftDataParameters>
  Target& WithRedshiftDataParameters(RedshiftDataParametersT&& value) {
    SetRedshiftDataParameters(std::forward<RedshiftDataParametersT>(value));
    return *this;
  }
 
 
  inline const SageMakerPipelineParameters& GetSageMakerPipelineParameters() const { return m_sageMakerPipelineParameters; }
  inline bool SageMakerPipelineParametersHasBeenSet() const { return m_sageMakerPipelineParametersHasBeenSet; }
  template <typename SageMakerPipelineParametersT = SageMakerPipelineParameters>
  void SetSageMakerPipelineParameters(SageMakerPipelineParametersT&& value) {
    m_sageMakerPipelineParametersHasBeenSet = true;
    m_sageMakerPipelineParameters = std::forward<SageMakerPipelineParametersT>(value);
  }
  template <typename SageMakerPipelineParametersT = SageMakerPipelineParameters>
  Target& WithSageMakerPipelineParameters(SageMakerPipelineParametersT&& value) {
    SetSageMakerPipelineParameters(std::forward<SageMakerPipelineParametersT>(value));
    return *this;
  }
 
 
  inline const DeadLetterConfig& GetDeadLetterConfig() const { return m_deadLetterConfig; }
  inline bool DeadLetterConfigHasBeenSet() const { return m_deadLetterConfigHasBeenSet; }
  template <typename DeadLetterConfigT = DeadLetterConfig>
  void SetDeadLetterConfig(DeadLetterConfigT&& value) {
    m_deadLetterConfigHasBeenSet = true;
    m_deadLetterConfig = std::forward<DeadLetterConfigT>(value);
  }
  template <typename DeadLetterConfigT = DeadLetterConfig>
  Target& WithDeadLetterConfig(DeadLetterConfigT&& value) {
    SetDeadLetterConfig(std::forward<DeadLetterConfigT>(value));
    return *this;
  }
 
 
  inline const RetryPolicy& GetRetryPolicy() const { return m_retryPolicy; }
  inline bool RetryPolicyHasBeenSet() const { return m_retryPolicyHasBeenSet; }
  template <typename RetryPolicyT = RetryPolicy>
  void SetRetryPolicy(RetryPolicyT&& value) {
    m_retryPolicyHasBeenSet = true;
    m_retryPolicy = std::forward<RetryPolicyT>(value);
  }
  template <typename RetryPolicyT = RetryPolicy>
  Target& WithRetryPolicy(RetryPolicyT&& value) {
    SetRetryPolicy(std::forward<RetryPolicyT>(value));
    return *this;
  }
 private:
  Aws::String m_id;
 
  Aws::String m_arn;
 
  Aws::String m_roleArn;
 
  Aws::String m_input;
 
  Aws::String m_inputPath;
 
  InputTransformer m_inputTransformer;
 
  KinesisParameters m_kinesisParameters;
 
  RunCommandParameters m_runCommandParameters;
 
  EcsParameters m_ecsParameters;
 
  BatchParameters m_batchParameters;
 
  SqsParameters m_sqsParameters;
 
  HttpParameters m_httpParameters;
 
  RedshiftDataParameters m_redshiftDataParameters;
 
  SageMakerPipelineParameters m_sageMakerPipelineParameters;
 
  DeadLetterConfig m_deadLetterConfig;
 
  RetryPolicy m_retryPolicy;
  bool m_idHasBeenSet = false;
  bool m_arnHasBeenSet = false;
  bool m_roleArnHasBeenSet = false;
  bool m_inputHasBeenSet = false;
  bool m_inputPathHasBeenSet = false;
  bool m_inputTransformerHasBeenSet = false;
  bool m_kinesisParametersHasBeenSet = false;
  bool m_runCommandParametersHasBeenSet = false;
  bool m_ecsParametersHasBeenSet = false;
  bool m_batchParametersHasBeenSet = false;
  bool m_sqsParametersHasBeenSet = false;
  bool m_httpParametersHasBeenSet = false;
  bool m_redshiftDataParametersHasBeenSet = false;
  bool m_sageMakerPipelineParametersHasBeenSet = false;
  bool m_deadLetterConfigHasBeenSet = false;
  bool m_retryPolicyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CloudWatchEvents
}  // namespace Aws