StepExecution.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#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/ssm/SSM_EXPORTS.h>
#include <aws/ssm/model/AlarmStateInformation.h>
#include <aws/ssm/model/AutomationExecutionStatus.h>
#include <aws/ssm/model/FailureDetails.h>
#include <aws/ssm/model/ParentStepDetails.h>
#include <aws/ssm/model/Target.h>
#include <aws/ssm/model/TargetLocation.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SSM {
namespace Model {
 
class StepExecution {
 public:
  AWS_SSM_API StepExecution() = default;
  AWS_SSM_API StepExecution(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API StepExecution& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetStepName() const { return m_stepName; }
  inline bool StepNameHasBeenSet() const { return m_stepNameHasBeenSet; }
  template <typename StepNameT = Aws::String>
  void SetStepName(StepNameT&& value) {
    m_stepNameHasBeenSet = true;
    m_stepName = std::forward<StepNameT>(value);
  }
  template <typename StepNameT = Aws::String>
  StepExecution& WithStepName(StepNameT&& value) {
    SetStepName(std::forward<StepNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAction() const { return m_action; }
  inline bool ActionHasBeenSet() const { return m_actionHasBeenSet; }
  template <typename ActionT = Aws::String>
  void SetAction(ActionT&& value) {
    m_actionHasBeenSet = true;
    m_action = std::forward<ActionT>(value);
  }
  template <typename ActionT = Aws::String>
  StepExecution& WithAction(ActionT&& value) {
    SetAction(std::forward<ActionT>(value));
    return *this;
  }
 
 
  inline long long GetTimeoutSeconds() const { return m_timeoutSeconds; }
  inline bool TimeoutSecondsHasBeenSet() const { return m_timeoutSecondsHasBeenSet; }
  inline void SetTimeoutSeconds(long long value) {
    m_timeoutSecondsHasBeenSet = true;
    m_timeoutSeconds = value;
  }
  inline StepExecution& WithTimeoutSeconds(long long value) {
    SetTimeoutSeconds(value);
    return *this;
  }
 
 
  inline const Aws::String& GetOnFailure() const { return m_onFailure; }
  inline bool OnFailureHasBeenSet() const { return m_onFailureHasBeenSet; }
  template <typename OnFailureT = Aws::String>
  void SetOnFailure(OnFailureT&& value) {
    m_onFailureHasBeenSet = true;
    m_onFailure = std::forward<OnFailureT>(value);
  }
  template <typename OnFailureT = Aws::String>
  StepExecution& WithOnFailure(OnFailureT&& value) {
    SetOnFailure(std::forward<OnFailureT>(value));
    return *this;
  }
 
 
  inline int GetMaxAttempts() const { return m_maxAttempts; }
  inline bool MaxAttemptsHasBeenSet() const { return m_maxAttemptsHasBeenSet; }
  inline void SetMaxAttempts(int value) {
    m_maxAttemptsHasBeenSet = true;
    m_maxAttempts = value;
  }
  inline StepExecution& WithMaxAttempts(int value) {
    SetMaxAttempts(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetExecutionStartTime() const { return m_executionStartTime; }
  inline bool ExecutionStartTimeHasBeenSet() const { return m_executionStartTimeHasBeenSet; }
  template <typename ExecutionStartTimeT = Aws::Utils::DateTime>
  void SetExecutionStartTime(ExecutionStartTimeT&& value) {
    m_executionStartTimeHasBeenSet = true;
    m_executionStartTime = std::forward<ExecutionStartTimeT>(value);
  }
  template <typename ExecutionStartTimeT = Aws::Utils::DateTime>
  StepExecution& WithExecutionStartTime(ExecutionStartTimeT&& value) {
    SetExecutionStartTime(std::forward<ExecutionStartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetExecutionEndTime() const { return m_executionEndTime; }
  inline bool ExecutionEndTimeHasBeenSet() const { return m_executionEndTimeHasBeenSet; }
  template <typename ExecutionEndTimeT = Aws::Utils::DateTime>
  void SetExecutionEndTime(ExecutionEndTimeT&& value) {
    m_executionEndTimeHasBeenSet = true;
    m_executionEndTime = std::forward<ExecutionEndTimeT>(value);
  }
  template <typename ExecutionEndTimeT = Aws::Utils::DateTime>
  StepExecution& WithExecutionEndTime(ExecutionEndTimeT&& value) {
    SetExecutionEndTime(std::forward<ExecutionEndTimeT>(value));
    return *this;
  }
 
 
  inline AutomationExecutionStatus GetStepStatus() const { return m_stepStatus; }
  inline bool StepStatusHasBeenSet() const { return m_stepStatusHasBeenSet; }
  inline void SetStepStatus(AutomationExecutionStatus value) {
    m_stepStatusHasBeenSet = true;
    m_stepStatus = value;
  }
  inline StepExecution& WithStepStatus(AutomationExecutionStatus value) {
    SetStepStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetResponseCode() const { return m_responseCode; }
  inline bool ResponseCodeHasBeenSet() const { return m_responseCodeHasBeenSet; }
  template <typename ResponseCodeT = Aws::String>
  void SetResponseCode(ResponseCodeT&& value) {
    m_responseCodeHasBeenSet = true;
    m_responseCode = std::forward<ResponseCodeT>(value);
  }
  template <typename ResponseCodeT = Aws::String>
  StepExecution& WithResponseCode(ResponseCodeT&& value) {
    SetResponseCode(std::forward<ResponseCodeT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetInputs() const { return m_inputs; }
  inline bool InputsHasBeenSet() const { return m_inputsHasBeenSet; }
  template <typename InputsT = Aws::Map<Aws::String, Aws::String>>
  void SetInputs(InputsT&& value) {
    m_inputsHasBeenSet = true;
    m_inputs = std::forward<InputsT>(value);
  }
  template <typename InputsT = Aws::Map<Aws::String, Aws::String>>
  StepExecution& WithInputs(InputsT&& value) {
    SetInputs(std::forward<InputsT>(value));
    return *this;
  }
  template <typename InputsKeyT = Aws::String, typename InputsValueT = Aws::String>
  StepExecution& AddInputs(InputsKeyT&& key, InputsValueT&& value) {
    m_inputsHasBeenSet = true;
    m_inputs.emplace(std::forward<InputsKeyT>(key), std::forward<InputsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::Vector<Aws::String>>& GetOutputs() const { return m_outputs; }
  inline bool OutputsHasBeenSet() const { return m_outputsHasBeenSet; }
  template <typename OutputsT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  void SetOutputs(OutputsT&& value) {
    m_outputsHasBeenSet = true;
    m_outputs = std::forward<OutputsT>(value);
  }
  template <typename OutputsT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  StepExecution& WithOutputs(OutputsT&& value) {
    SetOutputs(std::forward<OutputsT>(value));
    return *this;
  }
  template <typename OutputsKeyT = Aws::String, typename OutputsValueT = Aws::Vector<Aws::String>>
  StepExecution& AddOutputs(OutputsKeyT&& key, OutputsValueT&& value) {
    m_outputsHasBeenSet = true;
    m_outputs.emplace(std::forward<OutputsKeyT>(key), std::forward<OutputsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResponse() const { return m_response; }
  inline bool ResponseHasBeenSet() const { return m_responseHasBeenSet; }
  template <typename ResponseT = Aws::String>
  void SetResponse(ResponseT&& value) {
    m_responseHasBeenSet = true;
    m_response = std::forward<ResponseT>(value);
  }
  template <typename ResponseT = Aws::String>
  StepExecution& WithResponse(ResponseT&& value) {
    SetResponse(std::forward<ResponseT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFailureMessage() const { return m_failureMessage; }
  inline bool FailureMessageHasBeenSet() const { return m_failureMessageHasBeenSet; }
  template <typename FailureMessageT = Aws::String>
  void SetFailureMessage(FailureMessageT&& value) {
    m_failureMessageHasBeenSet = true;
    m_failureMessage = std::forward<FailureMessageT>(value);
  }
  template <typename FailureMessageT = Aws::String>
  StepExecution& WithFailureMessage(FailureMessageT&& value) {
    SetFailureMessage(std::forward<FailureMessageT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetWarningMessage() const { return m_warningMessage; }
  inline bool WarningMessageHasBeenSet() const { return m_warningMessageHasBeenSet; }
  template <typename WarningMessageT = Aws::String>
  void SetWarningMessage(WarningMessageT&& value) {
    m_warningMessageHasBeenSet = true;
    m_warningMessage = std::forward<WarningMessageT>(value);
  }
  template <typename WarningMessageT = Aws::String>
  StepExecution& WithWarningMessage(WarningMessageT&& value) {
    SetWarningMessage(std::forward<WarningMessageT>(value));
    return *this;
  }
 
 
  inline const FailureDetails& GetFailureDetails() const { return m_failureDetails; }
  inline bool FailureDetailsHasBeenSet() const { return m_failureDetailsHasBeenSet; }
  template <typename FailureDetailsT = FailureDetails>
  void SetFailureDetails(FailureDetailsT&& value) {
    m_failureDetailsHasBeenSet = true;
    m_failureDetails = std::forward<FailureDetailsT>(value);
  }
  template <typename FailureDetailsT = FailureDetails>
  StepExecution& WithFailureDetails(FailureDetailsT&& value) {
    SetFailureDetails(std::forward<FailureDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStepExecutionId() const { return m_stepExecutionId; }
  inline bool StepExecutionIdHasBeenSet() const { return m_stepExecutionIdHasBeenSet; }
  template <typename StepExecutionIdT = Aws::String>
  void SetStepExecutionId(StepExecutionIdT&& value) {
    m_stepExecutionIdHasBeenSet = true;
    m_stepExecutionId = std::forward<StepExecutionIdT>(value);
  }
  template <typename StepExecutionIdT = Aws::String>
  StepExecution& WithStepExecutionId(StepExecutionIdT&& value) {
    SetStepExecutionId(std::forward<StepExecutionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::Vector<Aws::String>>& GetOverriddenParameters() const { return m_overriddenParameters; }
  inline bool OverriddenParametersHasBeenSet() const { return m_overriddenParametersHasBeenSet; }
  template <typename OverriddenParametersT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  void SetOverriddenParameters(OverriddenParametersT&& value) {
    m_overriddenParametersHasBeenSet = true;
    m_overriddenParameters = std::forward<OverriddenParametersT>(value);
  }
  template <typename OverriddenParametersT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  StepExecution& WithOverriddenParameters(OverriddenParametersT&& value) {
    SetOverriddenParameters(std::forward<OverriddenParametersT>(value));
    return *this;
  }
  template <typename OverriddenParametersKeyT = Aws::String, typename OverriddenParametersValueT = Aws::Vector<Aws::String>>
  StepExecution& AddOverriddenParameters(OverriddenParametersKeyT&& key, OverriddenParametersValueT&& value) {
    m_overriddenParametersHasBeenSet = true;
    m_overriddenParameters.emplace(std::forward<OverriddenParametersKeyT>(key), std::forward<OverriddenParametersValueT>(value));
    return *this;
  }
 
 
  inline bool GetIsEnd() const { return m_isEnd; }
  inline bool IsEndHasBeenSet() const { return m_isEndHasBeenSet; }
  inline void SetIsEnd(bool value) {
    m_isEndHasBeenSet = true;
    m_isEnd = value;
  }
  inline StepExecution& WithIsEnd(bool value) {
    SetIsEnd(value);
    return *this;
  }
 
 
  inline const Aws::String& GetNextStep() const { return m_nextStep; }
  inline bool NextStepHasBeenSet() const { return m_nextStepHasBeenSet; }
  template <typename NextStepT = Aws::String>
  void SetNextStep(NextStepT&& value) {
    m_nextStepHasBeenSet = true;
    m_nextStep = std::forward<NextStepT>(value);
  }
  template <typename NextStepT = Aws::String>
  StepExecution& WithNextStep(NextStepT&& value) {
    SetNextStep(std::forward<NextStepT>(value));
    return *this;
  }
 
 
  inline bool GetIsCritical() const { return m_isCritical; }
  inline bool IsCriticalHasBeenSet() const { return m_isCriticalHasBeenSet; }
  inline void SetIsCritical(bool value) {
    m_isCriticalHasBeenSet = true;
    m_isCritical = value;
  }
  inline StepExecution& WithIsCritical(bool value) {
    SetIsCritical(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetValidNextSteps() const { return m_validNextSteps; }
  inline bool ValidNextStepsHasBeenSet() const { return m_validNextStepsHasBeenSet; }
  template <typename ValidNextStepsT = Aws::Vector<Aws::String>>
  void SetValidNextSteps(ValidNextStepsT&& value) {
    m_validNextStepsHasBeenSet = true;
    m_validNextSteps = std::forward<ValidNextStepsT>(value);
  }
  template <typename ValidNextStepsT = Aws::Vector<Aws::String>>
  StepExecution& WithValidNextSteps(ValidNextStepsT&& value) {
    SetValidNextSteps(std::forward<ValidNextStepsT>(value));
    return *this;
  }
  template <typename ValidNextStepsT = Aws::String>
  StepExecution& AddValidNextSteps(ValidNextStepsT&& value) {
    m_validNextStepsHasBeenSet = true;
    m_validNextSteps.emplace_back(std::forward<ValidNextStepsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Target>& GetTargets() const { return m_targets; }
  inline bool TargetsHasBeenSet() const { return m_targetsHasBeenSet; }
  template <typename TargetsT = Aws::Vector<Target>>
  void SetTargets(TargetsT&& value) {
    m_targetsHasBeenSet = true;
    m_targets = std::forward<TargetsT>(value);
  }
  template <typename TargetsT = Aws::Vector<Target>>
  StepExecution& WithTargets(TargetsT&& value) {
    SetTargets(std::forward<TargetsT>(value));
    return *this;
  }
  template <typename TargetsT = Target>
  StepExecution& AddTargets(TargetsT&& value) {
    m_targetsHasBeenSet = true;
    m_targets.emplace_back(std::forward<TargetsT>(value));
    return *this;
  }
 
 
  inline const TargetLocation& GetTargetLocation() const { return m_targetLocation; }
  inline bool TargetLocationHasBeenSet() const { return m_targetLocationHasBeenSet; }
  template <typename TargetLocationT = TargetLocation>
  void SetTargetLocation(TargetLocationT&& value) {
    m_targetLocationHasBeenSet = true;
    m_targetLocation = std::forward<TargetLocationT>(value);
  }
  template <typename TargetLocationT = TargetLocation>
  StepExecution& WithTargetLocation(TargetLocationT&& value) {
    SetTargetLocation(std::forward<TargetLocationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AlarmStateInformation>& GetTriggeredAlarms() const { return m_triggeredAlarms; }
  inline bool TriggeredAlarmsHasBeenSet() const { return m_triggeredAlarmsHasBeenSet; }
  template <typename TriggeredAlarmsT = Aws::Vector<AlarmStateInformation>>
  void SetTriggeredAlarms(TriggeredAlarmsT&& value) {
    m_triggeredAlarmsHasBeenSet = true;
    m_triggeredAlarms = std::forward<TriggeredAlarmsT>(value);
  }
  template <typename TriggeredAlarmsT = Aws::Vector<AlarmStateInformation>>
  StepExecution& WithTriggeredAlarms(TriggeredAlarmsT&& value) {
    SetTriggeredAlarms(std::forward<TriggeredAlarmsT>(value));
    return *this;
  }
  template <typename TriggeredAlarmsT = AlarmStateInformation>
  StepExecution& AddTriggeredAlarms(TriggeredAlarmsT&& value) {
    m_triggeredAlarmsHasBeenSet = true;
    m_triggeredAlarms.emplace_back(std::forward<TriggeredAlarmsT>(value));
    return *this;
  }
 
 
  inline const ParentStepDetails& GetParentStepDetails() const { return m_parentStepDetails; }
  inline bool ParentStepDetailsHasBeenSet() const { return m_parentStepDetailsHasBeenSet; }
  template <typename ParentStepDetailsT = ParentStepDetails>
  void SetParentStepDetails(ParentStepDetailsT&& value) {
    m_parentStepDetailsHasBeenSet = true;
    m_parentStepDetails = std::forward<ParentStepDetailsT>(value);
  }
  template <typename ParentStepDetailsT = ParentStepDetails>
  StepExecution& WithParentStepDetails(ParentStepDetailsT&& value) {
    SetParentStepDetails(std::forward<ParentStepDetailsT>(value));
    return *this;
  }
 private:
  Aws::String m_stepName;
 
  Aws::String m_action;
 
  long long m_timeoutSeconds{0};
 
  Aws::String m_onFailure;
 
  int m_maxAttempts{0};
 
  Aws::Utils::DateTime m_executionStartTime{};
 
  Aws::Utils::DateTime m_executionEndTime{};
 
  AutomationExecutionStatus m_stepStatus{AutomationExecutionStatus::NOT_SET};
 
  Aws::String m_responseCode;
 
  Aws::Map<Aws::String, Aws::String> m_inputs;
 
  Aws::Map<Aws::String, Aws::Vector<Aws::String>> m_outputs;
 
  Aws::String m_response;
 
  Aws::String m_failureMessage;
 
  Aws::String m_warningMessage;
 
  FailureDetails m_failureDetails;
 
  Aws::String m_stepExecutionId;
 
  Aws::Map<Aws::String, Aws::Vector<Aws::String>> m_overriddenParameters;
 
  bool m_isEnd{false};
 
  Aws::String m_nextStep;
 
  bool m_isCritical{false};
 
  Aws::Vector<Aws::String> m_validNextSteps;
 
  Aws::Vector<Target> m_targets;
 
  TargetLocation m_targetLocation;
 
  Aws::Vector<AlarmStateInformation> m_triggeredAlarms;
 
  ParentStepDetails m_parentStepDetails;
  bool m_stepNameHasBeenSet = false;
  bool m_actionHasBeenSet = false;
  bool m_timeoutSecondsHasBeenSet = false;
  bool m_onFailureHasBeenSet = false;
  bool m_maxAttemptsHasBeenSet = false;
  bool m_executionStartTimeHasBeenSet = false;
  bool m_executionEndTimeHasBeenSet = false;
  bool m_stepStatusHasBeenSet = false;
  bool m_responseCodeHasBeenSet = false;
  bool m_inputsHasBeenSet = false;
  bool m_outputsHasBeenSet = false;
  bool m_responseHasBeenSet = false;
  bool m_failureMessageHasBeenSet = false;
  bool m_warningMessageHasBeenSet = false;
  bool m_failureDetailsHasBeenSet = false;
  bool m_stepExecutionIdHasBeenSet = false;
  bool m_overriddenParametersHasBeenSet = false;
  bool m_isEndHasBeenSet = false;
  bool m_nextStepHasBeenSet = false;
  bool m_isCriticalHasBeenSet = false;
  bool m_validNextStepsHasBeenSet = false;
  bool m_targetsHasBeenSet = false;
  bool m_targetLocationHasBeenSet = false;
  bool m_triggeredAlarmsHasBeenSet = false;
  bool m_parentStepDetailsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SSM
}  // namespace Aws