DeploymentInfo.h

 
#pragma once
#include <aws/codedeploy/CodeDeploy_EXPORTS.h>
#include <aws/codedeploy/model/AlarmConfiguration.h>
#include <aws/codedeploy/model/AutoRollbackConfiguration.h>
#include <aws/codedeploy/model/BlueGreenDeploymentConfiguration.h>
#include <aws/codedeploy/model/ComputePlatform.h>
#include <aws/codedeploy/model/DeploymentCreator.h>
#include <aws/codedeploy/model/DeploymentMode.h>
#include <aws/codedeploy/model/DeploymentOverview.h>
#include <aws/codedeploy/model/DeploymentStatus.h>
#include <aws/codedeploy/model/DeploymentStyle.h>
#include <aws/codedeploy/model/EC2DeploymentOptions.h>
#include <aws/codedeploy/model/ErrorInformation.h>
#include <aws/codedeploy/model/FileExistsBehavior.h>
#include <aws/codedeploy/model/LoadBalancerInfo.h>
#include <aws/codedeploy/model/RelatedDeployments.h>
#include <aws/codedeploy/model/RevisionLocation.h>
#include <aws/codedeploy/model/RollbackInfo.h>
#include <aws/codedeploy/model/TargetInstances.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CodeDeploy {
namespace Model {
 
class DeploymentInfo {
 public:
  AWS_CODEDEPLOY_API DeploymentInfo() = default;
  AWS_CODEDEPLOY_API DeploymentInfo(Aws::Utils::Json::JsonView jsonValue);
  AWS_CODEDEPLOY_API DeploymentInfo& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CODEDEPLOY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetApplicationName() const { return m_applicationName; }
  inline bool ApplicationNameHasBeenSet() const { return m_applicationNameHasBeenSet; }
  template <typename ApplicationNameT = Aws::String>
  void SetApplicationName(ApplicationNameT&& value) {
    m_applicationNameHasBeenSet = true;
    m_applicationName = std::forward<ApplicationNameT>(value);
  }
  template <typename ApplicationNameT = Aws::String>
  DeploymentInfo& WithApplicationName(ApplicationNameT&& value) {
    SetApplicationName(std::forward<ApplicationNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDeploymentGroupName() const { return m_deploymentGroupName; }
  inline bool DeploymentGroupNameHasBeenSet() const { return m_deploymentGroupNameHasBeenSet; }
  template <typename DeploymentGroupNameT = Aws::String>
  void SetDeploymentGroupName(DeploymentGroupNameT&& value) {
    m_deploymentGroupNameHasBeenSet = true;
    m_deploymentGroupName = std::forward<DeploymentGroupNameT>(value);
  }
  template <typename DeploymentGroupNameT = Aws::String>
  DeploymentInfo& WithDeploymentGroupName(DeploymentGroupNameT&& value) {
    SetDeploymentGroupName(std::forward<DeploymentGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDeploymentConfigName() const { return m_deploymentConfigName; }
  inline bool DeploymentConfigNameHasBeenSet() const { return m_deploymentConfigNameHasBeenSet; }
  template <typename DeploymentConfigNameT = Aws::String>
  void SetDeploymentConfigName(DeploymentConfigNameT&& value) {
    m_deploymentConfigNameHasBeenSet = true;
    m_deploymentConfigName = std::forward<DeploymentConfigNameT>(value);
  }
  template <typename DeploymentConfigNameT = Aws::String>
  DeploymentInfo& WithDeploymentConfigName(DeploymentConfigNameT&& value) {
    SetDeploymentConfigName(std::forward<DeploymentConfigNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDeploymentId() const { return m_deploymentId; }
  inline bool DeploymentIdHasBeenSet() const { return m_deploymentIdHasBeenSet; }
  template <typename DeploymentIdT = Aws::String>
  void SetDeploymentId(DeploymentIdT&& value) {
    m_deploymentIdHasBeenSet = true;
    m_deploymentId = std::forward<DeploymentIdT>(value);
  }
  template <typename DeploymentIdT = Aws::String>
  DeploymentInfo& WithDeploymentId(DeploymentIdT&& value) {
    SetDeploymentId(std::forward<DeploymentIdT>(value));
    return *this;
  }
 
 
  inline const RevisionLocation& GetPreviousRevision() const { return m_previousRevision; }
  inline bool PreviousRevisionHasBeenSet() const { return m_previousRevisionHasBeenSet; }
  template <typename PreviousRevisionT = RevisionLocation>
  void SetPreviousRevision(PreviousRevisionT&& value) {
    m_previousRevisionHasBeenSet = true;
    m_previousRevision = std::forward<PreviousRevisionT>(value);
  }
  template <typename PreviousRevisionT = RevisionLocation>
  DeploymentInfo& WithPreviousRevision(PreviousRevisionT&& value) {
    SetPreviousRevision(std::forward<PreviousRevisionT>(value));
    return *this;
  }
 
 
  inline const RevisionLocation& GetRevision() const { return m_revision; }
  inline bool RevisionHasBeenSet() const { return m_revisionHasBeenSet; }
  template <typename RevisionT = RevisionLocation>
  void SetRevision(RevisionT&& value) {
    m_revisionHasBeenSet = true;
    m_revision = std::forward<RevisionT>(value);
  }
  template <typename RevisionT = RevisionLocation>
  DeploymentInfo& WithRevision(RevisionT&& value) {
    SetRevision(std::forward<RevisionT>(value));
    return *this;
  }
 
 
  inline DeploymentStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(DeploymentStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline DeploymentInfo& WithStatus(DeploymentStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const ErrorInformation& GetErrorInformation() const { return m_errorInformation; }
  inline bool ErrorInformationHasBeenSet() const { return m_errorInformationHasBeenSet; }
  template <typename ErrorInformationT = ErrorInformation>
  void SetErrorInformation(ErrorInformationT&& value) {
    m_errorInformationHasBeenSet = true;
    m_errorInformation = std::forward<ErrorInformationT>(value);
  }
  template <typename ErrorInformationT = ErrorInformation>
  DeploymentInfo& WithErrorInformation(ErrorInformationT&& value) {
    SetErrorInformation(std::forward<ErrorInformationT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreateTime() const { return m_createTime; }
  inline bool CreateTimeHasBeenSet() const { return m_createTimeHasBeenSet; }
  template <typename CreateTimeT = Aws::Utils::DateTime>
  void SetCreateTime(CreateTimeT&& value) {
    m_createTimeHasBeenSet = true;
    m_createTime = std::forward<CreateTimeT>(value);
  }
  template <typename CreateTimeT = Aws::Utils::DateTime>
  DeploymentInfo& WithCreateTime(CreateTimeT&& value) {
    SetCreateTime(std::forward<CreateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStartTime() const { return m_startTime; }
  inline bool StartTimeHasBeenSet() const { return m_startTimeHasBeenSet; }
  template <typename StartTimeT = Aws::Utils::DateTime>
  void SetStartTime(StartTimeT&& value) {
    m_startTimeHasBeenSet = true;
    m_startTime = std::forward<StartTimeT>(value);
  }
  template <typename StartTimeT = Aws::Utils::DateTime>
  DeploymentInfo& WithStartTime(StartTimeT&& value) {
    SetStartTime(std::forward<StartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCompleteTime() const { return m_completeTime; }
  inline bool CompleteTimeHasBeenSet() const { return m_completeTimeHasBeenSet; }
  template <typename CompleteTimeT = Aws::Utils::DateTime>
  void SetCompleteTime(CompleteTimeT&& value) {
    m_completeTimeHasBeenSet = true;
    m_completeTime = std::forward<CompleteTimeT>(value);
  }
  template <typename CompleteTimeT = Aws::Utils::DateTime>
  DeploymentInfo& WithCompleteTime(CompleteTimeT&& value) {
    SetCompleteTime(std::forward<CompleteTimeT>(value));
    return *this;
  }
 
 
  inline const DeploymentOverview& GetDeploymentOverview() const { return m_deploymentOverview; }
  inline bool DeploymentOverviewHasBeenSet() const { return m_deploymentOverviewHasBeenSet; }
  template <typename DeploymentOverviewT = DeploymentOverview>
  void SetDeploymentOverview(DeploymentOverviewT&& value) {
    m_deploymentOverviewHasBeenSet = true;
    m_deploymentOverview = std::forward<DeploymentOverviewT>(value);
  }
  template <typename DeploymentOverviewT = DeploymentOverview>
  DeploymentInfo& WithDeploymentOverview(DeploymentOverviewT&& value) {
    SetDeploymentOverview(std::forward<DeploymentOverviewT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  DeploymentInfo& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline DeploymentCreator GetCreator() const { return m_creator; }
  inline bool CreatorHasBeenSet() const { return m_creatorHasBeenSet; }
  inline void SetCreator(DeploymentCreator value) {
    m_creatorHasBeenSet = true;
    m_creator = value;
  }
  inline DeploymentInfo& WithCreator(DeploymentCreator value) {
    SetCreator(value);
    return *this;
  }
 
 
  inline bool GetIgnoreApplicationStopFailures() const { return m_ignoreApplicationStopFailures; }
  inline bool IgnoreApplicationStopFailuresHasBeenSet() const { return m_ignoreApplicationStopFailuresHasBeenSet; }
  inline void SetIgnoreApplicationStopFailures(bool value) {
    m_ignoreApplicationStopFailuresHasBeenSet = true;
    m_ignoreApplicationStopFailures = value;
  }
  inline DeploymentInfo& WithIgnoreApplicationStopFailures(bool value) {
    SetIgnoreApplicationStopFailures(value);
    return *this;
  }
 
 
  inline const AutoRollbackConfiguration& GetAutoRollbackConfiguration() const { return m_autoRollbackConfiguration; }
  inline bool AutoRollbackConfigurationHasBeenSet() const { return m_autoRollbackConfigurationHasBeenSet; }
  template <typename AutoRollbackConfigurationT = AutoRollbackConfiguration>
  void SetAutoRollbackConfiguration(AutoRollbackConfigurationT&& value) {
    m_autoRollbackConfigurationHasBeenSet = true;
    m_autoRollbackConfiguration = std::forward<AutoRollbackConfigurationT>(value);
  }
  template <typename AutoRollbackConfigurationT = AutoRollbackConfiguration>
  DeploymentInfo& WithAutoRollbackConfiguration(AutoRollbackConfigurationT&& value) {
    SetAutoRollbackConfiguration(std::forward<AutoRollbackConfigurationT>(value));
    return *this;
  }
 
 
  inline bool GetUpdateOutdatedInstancesOnly() const { return m_updateOutdatedInstancesOnly; }
  inline bool UpdateOutdatedInstancesOnlyHasBeenSet() const { return m_updateOutdatedInstancesOnlyHasBeenSet; }
  inline void SetUpdateOutdatedInstancesOnly(bool value) {
    m_updateOutdatedInstancesOnlyHasBeenSet = true;
    m_updateOutdatedInstancesOnly = value;
  }
  inline DeploymentInfo& WithUpdateOutdatedInstancesOnly(bool value) {
    SetUpdateOutdatedInstancesOnly(value);
    return *this;
  }
 
 
  inline const RollbackInfo& GetRollbackInfo() const { return m_rollbackInfo; }
  inline bool RollbackInfoHasBeenSet() const { return m_rollbackInfoHasBeenSet; }
  template <typename RollbackInfoT = RollbackInfo>
  void SetRollbackInfo(RollbackInfoT&& value) {
    m_rollbackInfoHasBeenSet = true;
    m_rollbackInfo = std::forward<RollbackInfoT>(value);
  }
  template <typename RollbackInfoT = RollbackInfo>
  DeploymentInfo& WithRollbackInfo(RollbackInfoT&& value) {
    SetRollbackInfo(std::forward<RollbackInfoT>(value));
    return *this;
  }
 
 
  inline const DeploymentStyle& GetDeploymentStyle() const { return m_deploymentStyle; }
  inline bool DeploymentStyleHasBeenSet() const { return m_deploymentStyleHasBeenSet; }
  template <typename DeploymentStyleT = DeploymentStyle>
  void SetDeploymentStyle(DeploymentStyleT&& value) {
    m_deploymentStyleHasBeenSet = true;
    m_deploymentStyle = std::forward<DeploymentStyleT>(value);
  }
  template <typename DeploymentStyleT = DeploymentStyle>
  DeploymentInfo& WithDeploymentStyle(DeploymentStyleT&& value) {
    SetDeploymentStyle(std::forward<DeploymentStyleT>(value));
    return *this;
  }
 
 
  inline const TargetInstances& GetTargetInstances() const { return m_targetInstances; }
  inline bool TargetInstancesHasBeenSet() const { return m_targetInstancesHasBeenSet; }
  template <typename TargetInstancesT = TargetInstances>
  void SetTargetInstances(TargetInstancesT&& value) {
    m_targetInstancesHasBeenSet = true;
    m_targetInstances = std::forward<TargetInstancesT>(value);
  }
  template <typename TargetInstancesT = TargetInstances>
  DeploymentInfo& WithTargetInstances(TargetInstancesT&& value) {
    SetTargetInstances(std::forward<TargetInstancesT>(value));
    return *this;
  }
 
 
  inline bool GetInstanceTerminationWaitTimeStarted() const { return m_instanceTerminationWaitTimeStarted; }
  inline bool InstanceTerminationWaitTimeStartedHasBeenSet() const { return m_instanceTerminationWaitTimeStartedHasBeenSet; }
  inline void SetInstanceTerminationWaitTimeStarted(bool value) {
    m_instanceTerminationWaitTimeStartedHasBeenSet = true;
    m_instanceTerminationWaitTimeStarted = value;
  }
  inline DeploymentInfo& WithInstanceTerminationWaitTimeStarted(bool value) {
    SetInstanceTerminationWaitTimeStarted(value);
    return *this;
  }
 
 
  inline const BlueGreenDeploymentConfiguration& GetBlueGreenDeploymentConfiguration() const { return m_blueGreenDeploymentConfiguration; }
  inline bool BlueGreenDeploymentConfigurationHasBeenSet() const { return m_blueGreenDeploymentConfigurationHasBeenSet; }
  template <typename BlueGreenDeploymentConfigurationT = BlueGreenDeploymentConfiguration>
  void SetBlueGreenDeploymentConfiguration(BlueGreenDeploymentConfigurationT&& value) {
    m_blueGreenDeploymentConfigurationHasBeenSet = true;
    m_blueGreenDeploymentConfiguration = std::forward<BlueGreenDeploymentConfigurationT>(value);
  }
  template <typename BlueGreenDeploymentConfigurationT = BlueGreenDeploymentConfiguration>
  DeploymentInfo& WithBlueGreenDeploymentConfiguration(BlueGreenDeploymentConfigurationT&& value) {
    SetBlueGreenDeploymentConfiguration(std::forward<BlueGreenDeploymentConfigurationT>(value));
    return *this;
  }
 
 
  inline const LoadBalancerInfo& GetLoadBalancerInfo() const { return m_loadBalancerInfo; }
  inline bool LoadBalancerInfoHasBeenSet() const { return m_loadBalancerInfoHasBeenSet; }
  template <typename LoadBalancerInfoT = LoadBalancerInfo>
  void SetLoadBalancerInfo(LoadBalancerInfoT&& value) {
    m_loadBalancerInfoHasBeenSet = true;
    m_loadBalancerInfo = std::forward<LoadBalancerInfoT>(value);
  }
  template <typename LoadBalancerInfoT = LoadBalancerInfo>
  DeploymentInfo& WithLoadBalancerInfo(LoadBalancerInfoT&& value) {
    SetLoadBalancerInfo(std::forward<LoadBalancerInfoT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAdditionalDeploymentStatusInfo() const { return m_additionalDeploymentStatusInfo; }
  inline bool AdditionalDeploymentStatusInfoHasBeenSet() const { return m_additionalDeploymentStatusInfoHasBeenSet; }
  template <typename AdditionalDeploymentStatusInfoT = Aws::String>
  void SetAdditionalDeploymentStatusInfo(AdditionalDeploymentStatusInfoT&& value) {
    m_additionalDeploymentStatusInfoHasBeenSet = true;
    m_additionalDeploymentStatusInfo = std::forward<AdditionalDeploymentStatusInfoT>(value);
  }
  template <typename AdditionalDeploymentStatusInfoT = Aws::String>
  DeploymentInfo& WithAdditionalDeploymentStatusInfo(AdditionalDeploymentStatusInfoT&& value) {
    SetAdditionalDeploymentStatusInfo(std::forward<AdditionalDeploymentStatusInfoT>(value));
    return *this;
  }
 
 
  inline FileExistsBehavior GetFileExistsBehavior() const { return m_fileExistsBehavior; }
  inline bool FileExistsBehaviorHasBeenSet() const { return m_fileExistsBehaviorHasBeenSet; }
  inline void SetFileExistsBehavior(FileExistsBehavior value) {
    m_fileExistsBehaviorHasBeenSet = true;
    m_fileExistsBehavior = value;
  }
  inline DeploymentInfo& WithFileExistsBehavior(FileExistsBehavior value) {
    SetFileExistsBehavior(value);
    return *this;
  }
 
 
  inline DeploymentMode GetDeploymentMode() const { return m_deploymentMode; }
  inline bool DeploymentModeHasBeenSet() const { return m_deploymentModeHasBeenSet; }
  inline void SetDeploymentMode(DeploymentMode value) {
    m_deploymentModeHasBeenSet = true;
    m_deploymentMode = value;
  }
  inline DeploymentInfo& WithDeploymentMode(DeploymentMode value) {
    SetDeploymentMode(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetDeploymentStatusMessages() const { return m_deploymentStatusMessages; }
  inline bool DeploymentStatusMessagesHasBeenSet() const { return m_deploymentStatusMessagesHasBeenSet; }
  template <typename DeploymentStatusMessagesT = Aws::Vector<Aws::String>>
  void SetDeploymentStatusMessages(DeploymentStatusMessagesT&& value) {
    m_deploymentStatusMessagesHasBeenSet = true;
    m_deploymentStatusMessages = std::forward<DeploymentStatusMessagesT>(value);
  }
  template <typename DeploymentStatusMessagesT = Aws::Vector<Aws::String>>
  DeploymentInfo& WithDeploymentStatusMessages(DeploymentStatusMessagesT&& value) {
    SetDeploymentStatusMessages(std::forward<DeploymentStatusMessagesT>(value));
    return *this;
  }
  template <typename DeploymentStatusMessagesT = Aws::String>
  DeploymentInfo& AddDeploymentStatusMessages(DeploymentStatusMessagesT&& value) {
    m_deploymentStatusMessagesHasBeenSet = true;
    m_deploymentStatusMessages.emplace_back(std::forward<DeploymentStatusMessagesT>(value));
    return *this;
  }
 
 
  inline ComputePlatform GetComputePlatform() const { return m_computePlatform; }
  inline bool ComputePlatformHasBeenSet() const { return m_computePlatformHasBeenSet; }
  inline void SetComputePlatform(ComputePlatform value) {
    m_computePlatformHasBeenSet = true;
    m_computePlatform = value;
  }
  inline DeploymentInfo& WithComputePlatform(ComputePlatform value) {
    SetComputePlatform(value);
    return *this;
  }
 
 
  inline const Aws::String& GetExternalId() const { return m_externalId; }
  inline bool ExternalIdHasBeenSet() const { return m_externalIdHasBeenSet; }
  template <typename ExternalIdT = Aws::String>
  void SetExternalId(ExternalIdT&& value) {
    m_externalIdHasBeenSet = true;
    m_externalId = std::forward<ExternalIdT>(value);
  }
  template <typename ExternalIdT = Aws::String>
  DeploymentInfo& WithExternalId(ExternalIdT&& value) {
    SetExternalId(std::forward<ExternalIdT>(value));
    return *this;
  }
 
 
  inline const RelatedDeployments& GetRelatedDeployments() const { return m_relatedDeployments; }
  inline bool RelatedDeploymentsHasBeenSet() const { return m_relatedDeploymentsHasBeenSet; }
  template <typename RelatedDeploymentsT = RelatedDeployments>
  void SetRelatedDeployments(RelatedDeploymentsT&& value) {
    m_relatedDeploymentsHasBeenSet = true;
    m_relatedDeployments = std::forward<RelatedDeploymentsT>(value);
  }
  template <typename RelatedDeploymentsT = RelatedDeployments>
  DeploymentInfo& WithRelatedDeployments(RelatedDeploymentsT&& value) {
    SetRelatedDeployments(std::forward<RelatedDeploymentsT>(value));
    return *this;
  }
 
 
  inline const AlarmConfiguration& GetOverrideAlarmConfiguration() const { return m_overrideAlarmConfiguration; }
  inline bool OverrideAlarmConfigurationHasBeenSet() const { return m_overrideAlarmConfigurationHasBeenSet; }
  template <typename OverrideAlarmConfigurationT = AlarmConfiguration>
  void SetOverrideAlarmConfiguration(OverrideAlarmConfigurationT&& value) {
    m_overrideAlarmConfigurationHasBeenSet = true;
    m_overrideAlarmConfiguration = std::forward<OverrideAlarmConfigurationT>(value);
  }
  template <typename OverrideAlarmConfigurationT = AlarmConfiguration>
  DeploymentInfo& WithOverrideAlarmConfiguration(OverrideAlarmConfigurationT&& value) {
    SetOverrideAlarmConfiguration(std::forward<OverrideAlarmConfigurationT>(value));
    return *this;
  }
 
 
  inline const EC2DeploymentOptions& GetEc2DeploymentOptions() const { return m_ec2DeploymentOptions; }
  inline bool Ec2DeploymentOptionsHasBeenSet() const { return m_ec2DeploymentOptionsHasBeenSet; }
  template <typename Ec2DeploymentOptionsT = EC2DeploymentOptions>
  void SetEc2DeploymentOptions(Ec2DeploymentOptionsT&& value) {
    m_ec2DeploymentOptionsHasBeenSet = true;
    m_ec2DeploymentOptions = std::forward<Ec2DeploymentOptionsT>(value);
  }
  template <typename Ec2DeploymentOptionsT = EC2DeploymentOptions>
  DeploymentInfo& WithEc2DeploymentOptions(Ec2DeploymentOptionsT&& value) {
    SetEc2DeploymentOptions(std::forward<Ec2DeploymentOptionsT>(value));
    return *this;
  }
 private:
  Aws::String m_applicationName;
 
  Aws::String m_deploymentGroupName;
 
  Aws::String m_deploymentConfigName;
 
  Aws::String m_deploymentId;
 
  RevisionLocation m_previousRevision;
 
  RevisionLocation m_revision;
 
  DeploymentStatus m_status{DeploymentStatus::NOT_SET};
 
  ErrorInformation m_errorInformation;
 
  Aws::Utils::DateTime m_createTime{};
 
  Aws::Utils::DateTime m_startTime{};
 
  Aws::Utils::DateTime m_completeTime{};
 
  DeploymentOverview m_deploymentOverview;
 
  Aws::String m_description;
 
  DeploymentCreator m_creator{DeploymentCreator::NOT_SET};
 
  bool m_ignoreApplicationStopFailures{false};
 
  AutoRollbackConfiguration m_autoRollbackConfiguration;
 
  bool m_updateOutdatedInstancesOnly{false};
 
  RollbackInfo m_rollbackInfo;
 
  DeploymentStyle m_deploymentStyle;
 
  TargetInstances m_targetInstances;
 
  bool m_instanceTerminationWaitTimeStarted{false};
 
  BlueGreenDeploymentConfiguration m_blueGreenDeploymentConfiguration;
 
  LoadBalancerInfo m_loadBalancerInfo;
 
  Aws::String m_additionalDeploymentStatusInfo;
 
  FileExistsBehavior m_fileExistsBehavior{FileExistsBehavior::NOT_SET};
 
  DeploymentMode m_deploymentMode{DeploymentMode::NOT_SET};
 
  Aws::Vector<Aws::String> m_deploymentStatusMessages;
 
  ComputePlatform m_computePlatform{ComputePlatform::NOT_SET};
 
  Aws::String m_externalId;
 
  RelatedDeployments m_relatedDeployments;
 
  AlarmConfiguration m_overrideAlarmConfiguration;
 
  EC2DeploymentOptions m_ec2DeploymentOptions;
  bool m_applicationNameHasBeenSet = false;
  bool m_deploymentGroupNameHasBeenSet = false;
  bool m_deploymentConfigNameHasBeenSet = false;
  bool m_deploymentIdHasBeenSet = false;
  bool m_previousRevisionHasBeenSet = false;
  bool m_revisionHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_errorInformationHasBeenSet = false;
  bool m_createTimeHasBeenSet = false;
  bool m_startTimeHasBeenSet = false;
  bool m_completeTimeHasBeenSet = false;
  bool m_deploymentOverviewHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_creatorHasBeenSet = false;
  bool m_ignoreApplicationStopFailuresHasBeenSet = false;
  bool m_autoRollbackConfigurationHasBeenSet = false;
  bool m_updateOutdatedInstancesOnlyHasBeenSet = false;
  bool m_rollbackInfoHasBeenSet = false;
  bool m_deploymentStyleHasBeenSet = false;
  bool m_targetInstancesHasBeenSet = false;
  bool m_instanceTerminationWaitTimeStartedHasBeenSet = false;
  bool m_blueGreenDeploymentConfigurationHasBeenSet = false;
  bool m_loadBalancerInfoHasBeenSet = false;
  bool m_additionalDeploymentStatusInfoHasBeenSet = false;
  bool m_fileExistsBehaviorHasBeenSet = false;
  bool m_deploymentModeHasBeenSet = false;
  bool m_deploymentStatusMessagesHasBeenSet = false;
  bool m_computePlatformHasBeenSet = false;
  bool m_externalIdHasBeenSet = false;
  bool m_relatedDeploymentsHasBeenSet = false;
  bool m_overrideAlarmConfigurationHasBeenSet = false;
  bool m_ec2DeploymentOptionsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CodeDeploy
}  // namespace Aws