AutomationExecution.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/AlarmConfiguration.h>
#include <aws/ssm/model/AlarmStateInformation.h>
#include <aws/ssm/model/AutomationExecutionStatus.h>
#include <aws/ssm/model/AutomationSubtype.h>
#include <aws/ssm/model/ExecutionMode.h>
#include <aws/ssm/model/ProgressCounters.h>
#include <aws/ssm/model/ResolvedTargets.h>
#include <aws/ssm/model/Runbook.h>
#include <aws/ssm/model/StepExecution.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 AutomationExecution {
 public:
  AWS_SSM_API AutomationExecution() = default;
  AWS_SSM_API AutomationExecution(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API AutomationExecution& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAutomationExecutionId() const { return m_automationExecutionId; }
  inline bool AutomationExecutionIdHasBeenSet() const { return m_automationExecutionIdHasBeenSet; }
  template <typename AutomationExecutionIdT = Aws::String>
  void SetAutomationExecutionId(AutomationExecutionIdT&& value) {
    m_automationExecutionIdHasBeenSet = true;
    m_automationExecutionId = std::forward<AutomationExecutionIdT>(value);
  }
  template <typename AutomationExecutionIdT = Aws::String>
  AutomationExecution& WithAutomationExecutionId(AutomationExecutionIdT&& value) {
    SetAutomationExecutionId(std::forward<AutomationExecutionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDocumentName() const { return m_documentName; }
  inline bool DocumentNameHasBeenSet() const { return m_documentNameHasBeenSet; }
  template <typename DocumentNameT = Aws::String>
  void SetDocumentName(DocumentNameT&& value) {
    m_documentNameHasBeenSet = true;
    m_documentName = std::forward<DocumentNameT>(value);
  }
  template <typename DocumentNameT = Aws::String>
  AutomationExecution& WithDocumentName(DocumentNameT&& value) {
    SetDocumentName(std::forward<DocumentNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDocumentVersion() const { return m_documentVersion; }
  inline bool DocumentVersionHasBeenSet() const { return m_documentVersionHasBeenSet; }
  template <typename DocumentVersionT = Aws::String>
  void SetDocumentVersion(DocumentVersionT&& value) {
    m_documentVersionHasBeenSet = true;
    m_documentVersion = std::forward<DocumentVersionT>(value);
  }
  template <typename DocumentVersionT = Aws::String>
  AutomationExecution& WithDocumentVersion(DocumentVersionT&& value) {
    SetDocumentVersion(std::forward<DocumentVersionT>(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>
  AutomationExecution& 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>
  AutomationExecution& WithExecutionEndTime(ExecutionEndTimeT&& value) {
    SetExecutionEndTime(std::forward<ExecutionEndTimeT>(value));
    return *this;
  }
 
 
  inline AutomationExecutionStatus GetAutomationExecutionStatus() const { return m_automationExecutionStatus; }
  inline bool AutomationExecutionStatusHasBeenSet() const { return m_automationExecutionStatusHasBeenSet; }
  inline void SetAutomationExecutionStatus(AutomationExecutionStatus value) {
    m_automationExecutionStatusHasBeenSet = true;
    m_automationExecutionStatus = value;
  }
  inline AutomationExecution& WithAutomationExecutionStatus(AutomationExecutionStatus value) {
    SetAutomationExecutionStatus(value);
    return *this;
  }
 
 
  inline const Aws::Vector<StepExecution>& GetStepExecutions() const { return m_stepExecutions; }
  inline bool StepExecutionsHasBeenSet() const { return m_stepExecutionsHasBeenSet; }
  template <typename StepExecutionsT = Aws::Vector<StepExecution>>
  void SetStepExecutions(StepExecutionsT&& value) {
    m_stepExecutionsHasBeenSet = true;
    m_stepExecutions = std::forward<StepExecutionsT>(value);
  }
  template <typename StepExecutionsT = Aws::Vector<StepExecution>>
  AutomationExecution& WithStepExecutions(StepExecutionsT&& value) {
    SetStepExecutions(std::forward<StepExecutionsT>(value));
    return *this;
  }
  template <typename StepExecutionsT = StepExecution>
  AutomationExecution& AddStepExecutions(StepExecutionsT&& value) {
    m_stepExecutionsHasBeenSet = true;
    m_stepExecutions.emplace_back(std::forward<StepExecutionsT>(value));
    return *this;
  }
 
 
  inline bool GetStepExecutionsTruncated() const { return m_stepExecutionsTruncated; }
  inline bool StepExecutionsTruncatedHasBeenSet() const { return m_stepExecutionsTruncatedHasBeenSet; }
  inline void SetStepExecutionsTruncated(bool value) {
    m_stepExecutionsTruncatedHasBeenSet = true;
    m_stepExecutionsTruncated = value;
  }
  inline AutomationExecution& WithStepExecutionsTruncated(bool value) {
    SetStepExecutionsTruncated(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::Vector<Aws::String>>& GetParameters() const { return m_parameters; }
  inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
  template <typename ParametersT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  void SetParameters(ParametersT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters = std::forward<ParametersT>(value);
  }
  template <typename ParametersT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  AutomationExecution& WithParameters(ParametersT&& value) {
    SetParameters(std::forward<ParametersT>(value));
    return *this;
  }
  template <typename ParametersKeyT = Aws::String, typename ParametersValueT = Aws::Vector<Aws::String>>
  AutomationExecution& AddParameters(ParametersKeyT&& key, ParametersValueT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters.emplace(std::forward<ParametersKeyT>(key), std::forward<ParametersValueT>(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>>>
  AutomationExecution& WithOutputs(OutputsT&& value) {
    SetOutputs(std::forward<OutputsT>(value));
    return *this;
  }
  template <typename OutputsKeyT = Aws::String, typename OutputsValueT = Aws::Vector<Aws::String>>
  AutomationExecution& 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& 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>
  AutomationExecution& 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>
  AutomationExecution& WithWarningMessage(WarningMessageT&& value) {
    SetWarningMessage(std::forward<WarningMessageT>(value));
    return *this;
  }
 
 
  inline ExecutionMode GetMode() const { return m_mode; }
  inline bool ModeHasBeenSet() const { return m_modeHasBeenSet; }
  inline void SetMode(ExecutionMode value) {
    m_modeHasBeenSet = true;
    m_mode = value;
  }
  inline AutomationExecution& WithMode(ExecutionMode value) {
    SetMode(value);
    return *this;
  }
 
 
  inline const Aws::String& GetParentAutomationExecutionId() const { return m_parentAutomationExecutionId; }
  inline bool ParentAutomationExecutionIdHasBeenSet() const { return m_parentAutomationExecutionIdHasBeenSet; }
  template <typename ParentAutomationExecutionIdT = Aws::String>
  void SetParentAutomationExecutionId(ParentAutomationExecutionIdT&& value) {
    m_parentAutomationExecutionIdHasBeenSet = true;
    m_parentAutomationExecutionId = std::forward<ParentAutomationExecutionIdT>(value);
  }
  template <typename ParentAutomationExecutionIdT = Aws::String>
  AutomationExecution& WithParentAutomationExecutionId(ParentAutomationExecutionIdT&& value) {
    SetParentAutomationExecutionId(std::forward<ParentAutomationExecutionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecutedBy() const { return m_executedBy; }
  inline bool ExecutedByHasBeenSet() const { return m_executedByHasBeenSet; }
  template <typename ExecutedByT = Aws::String>
  void SetExecutedBy(ExecutedByT&& value) {
    m_executedByHasBeenSet = true;
    m_executedBy = std::forward<ExecutedByT>(value);
  }
  template <typename ExecutedByT = Aws::String>
  AutomationExecution& WithExecutedBy(ExecutedByT&& value) {
    SetExecutedBy(std::forward<ExecutedByT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCurrentStepName() const { return m_currentStepName; }
  inline bool CurrentStepNameHasBeenSet() const { return m_currentStepNameHasBeenSet; }
  template <typename CurrentStepNameT = Aws::String>
  void SetCurrentStepName(CurrentStepNameT&& value) {
    m_currentStepNameHasBeenSet = true;
    m_currentStepName = std::forward<CurrentStepNameT>(value);
  }
  template <typename CurrentStepNameT = Aws::String>
  AutomationExecution& WithCurrentStepName(CurrentStepNameT&& value) {
    SetCurrentStepName(std::forward<CurrentStepNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCurrentAction() const { return m_currentAction; }
  inline bool CurrentActionHasBeenSet() const { return m_currentActionHasBeenSet; }
  template <typename CurrentActionT = Aws::String>
  void SetCurrentAction(CurrentActionT&& value) {
    m_currentActionHasBeenSet = true;
    m_currentAction = std::forward<CurrentActionT>(value);
  }
  template <typename CurrentActionT = Aws::String>
  AutomationExecution& WithCurrentAction(CurrentActionT&& value) {
    SetCurrentAction(std::forward<CurrentActionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetParameterName() const { return m_targetParameterName; }
  inline bool TargetParameterNameHasBeenSet() const { return m_targetParameterNameHasBeenSet; }
  template <typename TargetParameterNameT = Aws::String>
  void SetTargetParameterName(TargetParameterNameT&& value) {
    m_targetParameterNameHasBeenSet = true;
    m_targetParameterName = std::forward<TargetParameterNameT>(value);
  }
  template <typename TargetParameterNameT = Aws::String>
  AutomationExecution& WithTargetParameterName(TargetParameterNameT&& value) {
    SetTargetParameterName(std::forward<TargetParameterNameT>(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>>
  AutomationExecution& WithTargets(TargetsT&& value) {
    SetTargets(std::forward<TargetsT>(value));
    return *this;
  }
  template <typename TargetsT = Target>
  AutomationExecution& AddTargets(TargetsT&& value) {
    m_targetsHasBeenSet = true;
    m_targets.emplace_back(std::forward<TargetsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::Map<Aws::String, Aws::Vector<Aws::String>>>& GetTargetMaps() const { return m_targetMaps; }
  inline bool TargetMapsHasBeenSet() const { return m_targetMapsHasBeenSet; }
  template <typename TargetMapsT = Aws::Vector<Aws::Map<Aws::String, Aws::Vector<Aws::String>>>>
  void SetTargetMaps(TargetMapsT&& value) {
    m_targetMapsHasBeenSet = true;
    m_targetMaps = std::forward<TargetMapsT>(value);
  }
  template <typename TargetMapsT = Aws::Vector<Aws::Map<Aws::String, Aws::Vector<Aws::String>>>>
  AutomationExecution& WithTargetMaps(TargetMapsT&& value) {
    SetTargetMaps(std::forward<TargetMapsT>(value));
    return *this;
  }
  template <typename TargetMapsT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  AutomationExecution& AddTargetMaps(TargetMapsT&& value) {
    m_targetMapsHasBeenSet = true;
    m_targetMaps.emplace_back(std::forward<TargetMapsT>(value));
    return *this;
  }
 
 
  inline const ResolvedTargets& GetResolvedTargets() const { return m_resolvedTargets; }
  inline bool ResolvedTargetsHasBeenSet() const { return m_resolvedTargetsHasBeenSet; }
  template <typename ResolvedTargetsT = ResolvedTargets>
  void SetResolvedTargets(ResolvedTargetsT&& value) {
    m_resolvedTargetsHasBeenSet = true;
    m_resolvedTargets = std::forward<ResolvedTargetsT>(value);
  }
  template <typename ResolvedTargetsT = ResolvedTargets>
  AutomationExecution& WithResolvedTargets(ResolvedTargetsT&& value) {
    SetResolvedTargets(std::forward<ResolvedTargetsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMaxConcurrency() const { return m_maxConcurrency; }
  inline bool MaxConcurrencyHasBeenSet() const { return m_maxConcurrencyHasBeenSet; }
  template <typename MaxConcurrencyT = Aws::String>
  void SetMaxConcurrency(MaxConcurrencyT&& value) {
    m_maxConcurrencyHasBeenSet = true;
    m_maxConcurrency = std::forward<MaxConcurrencyT>(value);
  }
  template <typename MaxConcurrencyT = Aws::String>
  AutomationExecution& WithMaxConcurrency(MaxConcurrencyT&& value) {
    SetMaxConcurrency(std::forward<MaxConcurrencyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMaxErrors() const { return m_maxErrors; }
  inline bool MaxErrorsHasBeenSet() const { return m_maxErrorsHasBeenSet; }
  template <typename MaxErrorsT = Aws::String>
  void SetMaxErrors(MaxErrorsT&& value) {
    m_maxErrorsHasBeenSet = true;
    m_maxErrors = std::forward<MaxErrorsT>(value);
  }
  template <typename MaxErrorsT = Aws::String>
  AutomationExecution& WithMaxErrors(MaxErrorsT&& value) {
    SetMaxErrors(std::forward<MaxErrorsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTarget() const { return m_target; }
  inline bool TargetHasBeenSet() const { return m_targetHasBeenSet; }
  template <typename TargetT = Aws::String>
  void SetTarget(TargetT&& value) {
    m_targetHasBeenSet = true;
    m_target = std::forward<TargetT>(value);
  }
  template <typename TargetT = Aws::String>
  AutomationExecution& WithTarget(TargetT&& value) {
    SetTarget(std::forward<TargetT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<TargetLocation>& GetTargetLocations() const { return m_targetLocations; }
  inline bool TargetLocationsHasBeenSet() const { return m_targetLocationsHasBeenSet; }
  template <typename TargetLocationsT = Aws::Vector<TargetLocation>>
  void SetTargetLocations(TargetLocationsT&& value) {
    m_targetLocationsHasBeenSet = true;
    m_targetLocations = std::forward<TargetLocationsT>(value);
  }
  template <typename TargetLocationsT = Aws::Vector<TargetLocation>>
  AutomationExecution& WithTargetLocations(TargetLocationsT&& value) {
    SetTargetLocations(std::forward<TargetLocationsT>(value));
    return *this;
  }
  template <typename TargetLocationsT = TargetLocation>
  AutomationExecution& AddTargetLocations(TargetLocationsT&& value) {
    m_targetLocationsHasBeenSet = true;
    m_targetLocations.emplace_back(std::forward<TargetLocationsT>(value));
    return *this;
  }
 
 
  inline const ProgressCounters& GetProgressCounters() const { return m_progressCounters; }
  inline bool ProgressCountersHasBeenSet() const { return m_progressCountersHasBeenSet; }
  template <typename ProgressCountersT = ProgressCounters>
  void SetProgressCounters(ProgressCountersT&& value) {
    m_progressCountersHasBeenSet = true;
    m_progressCounters = std::forward<ProgressCountersT>(value);
  }
  template <typename ProgressCountersT = ProgressCounters>
  AutomationExecution& WithProgressCounters(ProgressCountersT&& value) {
    SetProgressCounters(std::forward<ProgressCountersT>(value));
    return *this;
  }
 
 
  inline const AlarmConfiguration& GetAlarmConfiguration() const { return m_alarmConfiguration; }
  inline bool AlarmConfigurationHasBeenSet() const { return m_alarmConfigurationHasBeenSet; }
  template <typename AlarmConfigurationT = AlarmConfiguration>
  void SetAlarmConfiguration(AlarmConfigurationT&& value) {
    m_alarmConfigurationHasBeenSet = true;
    m_alarmConfiguration = std::forward<AlarmConfigurationT>(value);
  }
  template <typename AlarmConfigurationT = AlarmConfiguration>
  AutomationExecution& WithAlarmConfiguration(AlarmConfigurationT&& value) {
    SetAlarmConfiguration(std::forward<AlarmConfigurationT>(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>>
  AutomationExecution& WithTriggeredAlarms(TriggeredAlarmsT&& value) {
    SetTriggeredAlarms(std::forward<TriggeredAlarmsT>(value));
    return *this;
  }
  template <typename TriggeredAlarmsT = AlarmStateInformation>
  AutomationExecution& AddTriggeredAlarms(TriggeredAlarmsT&& value) {
    m_triggeredAlarmsHasBeenSet = true;
    m_triggeredAlarms.emplace_back(std::forward<TriggeredAlarmsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetLocationsURL() const { return m_targetLocationsURL; }
  inline bool TargetLocationsURLHasBeenSet() const { return m_targetLocationsURLHasBeenSet; }
  template <typename TargetLocationsURLT = Aws::String>
  void SetTargetLocationsURL(TargetLocationsURLT&& value) {
    m_targetLocationsURLHasBeenSet = true;
    m_targetLocationsURL = std::forward<TargetLocationsURLT>(value);
  }
  template <typename TargetLocationsURLT = Aws::String>
  AutomationExecution& WithTargetLocationsURL(TargetLocationsURLT&& value) {
    SetTargetLocationsURL(std::forward<TargetLocationsURLT>(value));
    return *this;
  }
 
 
  inline AutomationSubtype GetAutomationSubtype() const { return m_automationSubtype; }
  inline bool AutomationSubtypeHasBeenSet() const { return m_automationSubtypeHasBeenSet; }
  inline void SetAutomationSubtype(AutomationSubtype value) {
    m_automationSubtypeHasBeenSet = true;
    m_automationSubtype = value;
  }
  inline AutomationExecution& WithAutomationSubtype(AutomationSubtype value) {
    SetAutomationSubtype(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetScheduledTime() const { return m_scheduledTime; }
  inline bool ScheduledTimeHasBeenSet() const { return m_scheduledTimeHasBeenSet; }
  template <typename ScheduledTimeT = Aws::Utils::DateTime>
  void SetScheduledTime(ScheduledTimeT&& value) {
    m_scheduledTimeHasBeenSet = true;
    m_scheduledTime = std::forward<ScheduledTimeT>(value);
  }
  template <typename ScheduledTimeT = Aws::Utils::DateTime>
  AutomationExecution& WithScheduledTime(ScheduledTimeT&& value) {
    SetScheduledTime(std::forward<ScheduledTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Runbook>& GetRunbooks() const { return m_runbooks; }
  inline bool RunbooksHasBeenSet() const { return m_runbooksHasBeenSet; }
  template <typename RunbooksT = Aws::Vector<Runbook>>
  void SetRunbooks(RunbooksT&& value) {
    m_runbooksHasBeenSet = true;
    m_runbooks = std::forward<RunbooksT>(value);
  }
  template <typename RunbooksT = Aws::Vector<Runbook>>
  AutomationExecution& WithRunbooks(RunbooksT&& value) {
    SetRunbooks(std::forward<RunbooksT>(value));
    return *this;
  }
  template <typename RunbooksT = Runbook>
  AutomationExecution& AddRunbooks(RunbooksT&& value) {
    m_runbooksHasBeenSet = true;
    m_runbooks.emplace_back(std::forward<RunbooksT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOpsItemId() const { return m_opsItemId; }
  inline bool OpsItemIdHasBeenSet() const { return m_opsItemIdHasBeenSet; }
  template <typename OpsItemIdT = Aws::String>
  void SetOpsItemId(OpsItemIdT&& value) {
    m_opsItemIdHasBeenSet = true;
    m_opsItemId = std::forward<OpsItemIdT>(value);
  }
  template <typename OpsItemIdT = Aws::String>
  AutomationExecution& WithOpsItemId(OpsItemIdT&& value) {
    SetOpsItemId(std::forward<OpsItemIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAssociationId() const { return m_associationId; }
  inline bool AssociationIdHasBeenSet() const { return m_associationIdHasBeenSet; }
  template <typename AssociationIdT = Aws::String>
  void SetAssociationId(AssociationIdT&& value) {
    m_associationIdHasBeenSet = true;
    m_associationId = std::forward<AssociationIdT>(value);
  }
  template <typename AssociationIdT = Aws::String>
  AutomationExecution& WithAssociationId(AssociationIdT&& value) {
    SetAssociationId(std::forward<AssociationIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetChangeRequestName() const { return m_changeRequestName; }
  inline bool ChangeRequestNameHasBeenSet() const { return m_changeRequestNameHasBeenSet; }
  template <typename ChangeRequestNameT = Aws::String>
  void SetChangeRequestName(ChangeRequestNameT&& value) {
    m_changeRequestNameHasBeenSet = true;
    m_changeRequestName = std::forward<ChangeRequestNameT>(value);
  }
  template <typename ChangeRequestNameT = Aws::String>
  AutomationExecution& WithChangeRequestName(ChangeRequestNameT&& value) {
    SetChangeRequestName(std::forward<ChangeRequestNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::Vector<Aws::String>>& GetVariables() const { return m_variables; }
  inline bool VariablesHasBeenSet() const { return m_variablesHasBeenSet; }
  template <typename VariablesT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  void SetVariables(VariablesT&& value) {
    m_variablesHasBeenSet = true;
    m_variables = std::forward<VariablesT>(value);
  }
  template <typename VariablesT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  AutomationExecution& WithVariables(VariablesT&& value) {
    SetVariables(std::forward<VariablesT>(value));
    return *this;
  }
  template <typename VariablesKeyT = Aws::String, typename VariablesValueT = Aws::Vector<Aws::String>>
  AutomationExecution& AddVariables(VariablesKeyT&& key, VariablesValueT&& value) {
    m_variablesHasBeenSet = true;
    m_variables.emplace(std::forward<VariablesKeyT>(key), std::forward<VariablesValueT>(value));
    return *this;
  }
 private:
  Aws::String m_automationExecutionId;
 
  Aws::String m_documentName;
 
  Aws::String m_documentVersion;
 
  Aws::Utils::DateTime m_executionStartTime{};
 
  Aws::Utils::DateTime m_executionEndTime{};
 
  AutomationExecutionStatus m_automationExecutionStatus{AutomationExecutionStatus::NOT_SET};
 
  Aws::Vector<StepExecution> m_stepExecutions;
 
  bool m_stepExecutionsTruncated{false};
 
  Aws::Map<Aws::String, Aws::Vector<Aws::String>> m_parameters;
 
  Aws::Map<Aws::String, Aws::Vector<Aws::String>> m_outputs;
 
  Aws::String m_failureMessage;
 
  Aws::String m_warningMessage;
 
  ExecutionMode m_mode{ExecutionMode::NOT_SET};
 
  Aws::String m_parentAutomationExecutionId;
 
  Aws::String m_executedBy;
 
  Aws::String m_currentStepName;
 
  Aws::String m_currentAction;
 
  Aws::String m_targetParameterName;
 
  Aws::Vector<Target> m_targets;
 
  Aws::Vector<Aws::Map<Aws::String, Aws::Vector<Aws::String>>> m_targetMaps;
 
  ResolvedTargets m_resolvedTargets;
 
  Aws::String m_maxConcurrency;
 
  Aws::String m_maxErrors;
 
  Aws::String m_target;
 
  Aws::Vector<TargetLocation> m_targetLocations;
 
  ProgressCounters m_progressCounters;
 
  AlarmConfiguration m_alarmConfiguration;
 
  Aws::Vector<AlarmStateInformation> m_triggeredAlarms;
 
  Aws::String m_targetLocationsURL;
 
  AutomationSubtype m_automationSubtype{AutomationSubtype::NOT_SET};
 
  Aws::Utils::DateTime m_scheduledTime{};
 
  Aws::Vector<Runbook> m_runbooks;
 
  Aws::String m_opsItemId;
 
  Aws::String m_associationId;
 
  Aws::String m_changeRequestName;
 
  Aws::Map<Aws::String, Aws::Vector<Aws::String>> m_variables;
  bool m_automationExecutionIdHasBeenSet = false;
  bool m_documentNameHasBeenSet = false;
  bool m_documentVersionHasBeenSet = false;
  bool m_executionStartTimeHasBeenSet = false;
  bool m_executionEndTimeHasBeenSet = false;
  bool m_automationExecutionStatusHasBeenSet = false;
  bool m_stepExecutionsHasBeenSet = false;
  bool m_stepExecutionsTruncatedHasBeenSet = false;
  bool m_parametersHasBeenSet = false;
  bool m_outputsHasBeenSet = false;
  bool m_failureMessageHasBeenSet = false;
  bool m_warningMessageHasBeenSet = false;
  bool m_modeHasBeenSet = false;
  bool m_parentAutomationExecutionIdHasBeenSet = false;
  bool m_executedByHasBeenSet = false;
  bool m_currentStepNameHasBeenSet = false;
  bool m_currentActionHasBeenSet = false;
  bool m_targetParameterNameHasBeenSet = false;
  bool m_targetsHasBeenSet = false;
  bool m_targetMapsHasBeenSet = false;
  bool m_resolvedTargetsHasBeenSet = false;
  bool m_maxConcurrencyHasBeenSet = false;
  bool m_maxErrorsHasBeenSet = false;
  bool m_targetHasBeenSet = false;
  bool m_targetLocationsHasBeenSet = false;
  bool m_progressCountersHasBeenSet = false;
  bool m_alarmConfigurationHasBeenSet = false;
  bool m_triggeredAlarmsHasBeenSet = false;
  bool m_targetLocationsURLHasBeenSet = false;
  bool m_automationSubtypeHasBeenSet = false;
  bool m_scheduledTimeHasBeenSet = false;
  bool m_runbooksHasBeenSet = false;
  bool m_opsItemIdHasBeenSet = false;
  bool m_associationIdHasBeenSet = false;
  bool m_changeRequestNameHasBeenSet = false;
  bool m_variablesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SSM
}  // namespace Aws