Target.h

 
#pragma once
#include <aws/events/CloudWatchEvents_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/events/model/InputTransformer.h>
#include <aws/events/model/KinesisParameters.h>
#include <aws/events/model/RunCommandParameters.h>
#include <aws/events/model/EcsParameters.h>
#include <aws/events/model/BatchParameters.h>
#include <aws/events/model/SqsParameters.h>
#include <aws/events/model/HttpParameters.h>
#include <aws/events/model/RedshiftDataParameters.h>
#include <aws/events/model/SageMakerPipelineParameters.h>
#include <aws/events/model/DeadLetterConfig.h>
#include <aws/events/model/RetryPolicy.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;
    bool m_idHasBeenSet = false;
 
    Aws::String m_arn;
    bool m_arnHasBeenSet = false;
 
    Aws::String m_roleArn;
    bool m_roleArnHasBeenSet = false;
 
    Aws::String m_input;
    bool m_inputHasBeenSet = false;
 
    Aws::String m_inputPath;
    bool m_inputPathHasBeenSet = false;
 
    InputTransformer m_inputTransformer;
    bool m_inputTransformerHasBeenSet = false;
 
    KinesisParameters m_kinesisParameters;
    bool m_kinesisParametersHasBeenSet = false;
 
    RunCommandParameters m_runCommandParameters;
    bool m_runCommandParametersHasBeenSet = false;
 
    EcsParameters m_ecsParameters;
    bool m_ecsParametersHasBeenSet = false;
 
    BatchParameters m_batchParameters;
    bool m_batchParametersHasBeenSet = false;
 
    SqsParameters m_sqsParameters;
    bool m_sqsParametersHasBeenSet = false;
 
    HttpParameters m_httpParameters;
    bool m_httpParametersHasBeenSet = false;
 
    RedshiftDataParameters m_redshiftDataParameters;
    bool m_redshiftDataParametersHasBeenSet = false;
 
    SageMakerPipelineParameters m_sageMakerPipelineParameters;
    bool m_sageMakerPipelineParametersHasBeenSet = false;
 
    DeadLetterConfig m_deadLetterConfig;
    bool m_deadLetterConfigHasBeenSet = false;
 
    RetryPolicy m_retryPolicy;
    bool m_retryPolicyHasBeenSet = false;
  };
 
} // namespace Model
} // namespace CloudWatchEvents
} // namespace Aws