DescribeTrainingJobResult.h

 
#pragma once
#include <aws/core/http/HttpResponse.h>
#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/sagemaker/SageMaker_EXPORTS.h>
#include <aws/sagemaker/model/AlgorithmSpecification.h>
#include <aws/sagemaker/model/Channel.h>
#include <aws/sagemaker/model/CheckpointConfig.h>
#include <aws/sagemaker/model/DebugHookConfig.h>
#include <aws/sagemaker/model/DebugRuleConfiguration.h>
#include <aws/sagemaker/model/DebugRuleEvaluationStatus.h>
#include <aws/sagemaker/model/ExperimentConfig.h>
#include <aws/sagemaker/model/InfraCheckConfig.h>
#include <aws/sagemaker/model/MetricData.h>
#include <aws/sagemaker/model/MlflowConfig.h>
#include <aws/sagemaker/model/MlflowDetails.h>
#include <aws/sagemaker/model/ModelArtifacts.h>
#include <aws/sagemaker/model/ModelPackageConfig.h>
#include <aws/sagemaker/model/OutputDataConfig.h>
#include <aws/sagemaker/model/ProfilerConfig.h>
#include <aws/sagemaker/model/ProfilerRuleConfiguration.h>
#include <aws/sagemaker/model/ProfilerRuleEvaluationStatus.h>
#include <aws/sagemaker/model/ProfilingStatus.h>
#include <aws/sagemaker/model/RemoteDebugConfig.h>
#include <aws/sagemaker/model/ResourceConfig.h>
#include <aws/sagemaker/model/RetryStrategy.h>
#include <aws/sagemaker/model/SecondaryStatus.h>
#include <aws/sagemaker/model/SecondaryStatusTransition.h>
#include <aws/sagemaker/model/ServerlessJobConfig.h>
#include <aws/sagemaker/model/StoppingCondition.h>
#include <aws/sagemaker/model/TensorBoardOutputConfig.h>
#include <aws/sagemaker/model/TrainingJobStatus.h>
#include <aws/sagemaker/model/TrainingProgressInfo.h>
#include <aws/sagemaker/model/VpcConfig.h>
#include <aws/sagemaker/model/WarmPoolStatus.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace SageMaker {
namespace Model {
class DescribeTrainingJobResult {
 public:
  AWS_SAGEMAKER_API DescribeTrainingJobResult() = default;
  AWS_SAGEMAKER_API DescribeTrainingJobResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_SAGEMAKER_API DescribeTrainingJobResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetTrainingJobName() const { return m_trainingJobName; }
  template <typename TrainingJobNameT = Aws::String>
  void SetTrainingJobName(TrainingJobNameT&& value) {
    m_trainingJobNameHasBeenSet = true;
    m_trainingJobName = std::forward<TrainingJobNameT>(value);
  }
  template <typename TrainingJobNameT = Aws::String>
  DescribeTrainingJobResult& WithTrainingJobName(TrainingJobNameT&& value) {
    SetTrainingJobName(std::forward<TrainingJobNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTrainingJobArn() const { return m_trainingJobArn; }
  template <typename TrainingJobArnT = Aws::String>
  void SetTrainingJobArn(TrainingJobArnT&& value) {
    m_trainingJobArnHasBeenSet = true;
    m_trainingJobArn = std::forward<TrainingJobArnT>(value);
  }
  template <typename TrainingJobArnT = Aws::String>
  DescribeTrainingJobResult& WithTrainingJobArn(TrainingJobArnT&& value) {
    SetTrainingJobArn(std::forward<TrainingJobArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTuningJobArn() const { return m_tuningJobArn; }
  template <typename TuningJobArnT = Aws::String>
  void SetTuningJobArn(TuningJobArnT&& value) {
    m_tuningJobArnHasBeenSet = true;
    m_tuningJobArn = std::forward<TuningJobArnT>(value);
  }
  template <typename TuningJobArnT = Aws::String>
  DescribeTrainingJobResult& WithTuningJobArn(TuningJobArnT&& value) {
    SetTuningJobArn(std::forward<TuningJobArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLabelingJobArn() const { return m_labelingJobArn; }
  template <typename LabelingJobArnT = Aws::String>
  void SetLabelingJobArn(LabelingJobArnT&& value) {
    m_labelingJobArnHasBeenSet = true;
    m_labelingJobArn = std::forward<LabelingJobArnT>(value);
  }
  template <typename LabelingJobArnT = Aws::String>
  DescribeTrainingJobResult& WithLabelingJobArn(LabelingJobArnT&& value) {
    SetLabelingJobArn(std::forward<LabelingJobArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAutoMLJobArn() const { return m_autoMLJobArn; }
  template <typename AutoMLJobArnT = Aws::String>
  void SetAutoMLJobArn(AutoMLJobArnT&& value) {
    m_autoMLJobArnHasBeenSet = true;
    m_autoMLJobArn = std::forward<AutoMLJobArnT>(value);
  }
  template <typename AutoMLJobArnT = Aws::String>
  DescribeTrainingJobResult& WithAutoMLJobArn(AutoMLJobArnT&& value) {
    SetAutoMLJobArn(std::forward<AutoMLJobArnT>(value));
    return *this;
  }
 
 
  inline const ModelArtifacts& GetModelArtifacts() const { return m_modelArtifacts; }
  template <typename ModelArtifactsT = ModelArtifacts>
  void SetModelArtifacts(ModelArtifactsT&& value) {
    m_modelArtifactsHasBeenSet = true;
    m_modelArtifacts = std::forward<ModelArtifactsT>(value);
  }
  template <typename ModelArtifactsT = ModelArtifacts>
  DescribeTrainingJobResult& WithModelArtifacts(ModelArtifactsT&& value) {
    SetModelArtifacts(std::forward<ModelArtifactsT>(value));
    return *this;
  }
 
 
  inline TrainingJobStatus GetTrainingJobStatus() const { return m_trainingJobStatus; }
  inline void SetTrainingJobStatus(TrainingJobStatus value) {
    m_trainingJobStatusHasBeenSet = true;
    m_trainingJobStatus = value;
  }
  inline DescribeTrainingJobResult& WithTrainingJobStatus(TrainingJobStatus value) {
    SetTrainingJobStatus(value);
    return *this;
  }
 
 
  inline SecondaryStatus GetSecondaryStatus() const { return m_secondaryStatus; }
  inline void SetSecondaryStatus(SecondaryStatus value) {
    m_secondaryStatusHasBeenSet = true;
    m_secondaryStatus = value;
  }
  inline DescribeTrainingJobResult& WithSecondaryStatus(SecondaryStatus value) {
    SetSecondaryStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetFailureReason() const { return m_failureReason; }
  template <typename FailureReasonT = Aws::String>
  void SetFailureReason(FailureReasonT&& value) {
    m_failureReasonHasBeenSet = true;
    m_failureReason = std::forward<FailureReasonT>(value);
  }
  template <typename FailureReasonT = Aws::String>
  DescribeTrainingJobResult& WithFailureReason(FailureReasonT&& value) {
    SetFailureReason(std::forward<FailureReasonT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetHyperParameters() const { return m_hyperParameters; }
  template <typename HyperParametersT = Aws::Map<Aws::String, Aws::String>>
  void SetHyperParameters(HyperParametersT&& value) {
    m_hyperParametersHasBeenSet = true;
    m_hyperParameters = std::forward<HyperParametersT>(value);
  }
  template <typename HyperParametersT = Aws::Map<Aws::String, Aws::String>>
  DescribeTrainingJobResult& WithHyperParameters(HyperParametersT&& value) {
    SetHyperParameters(std::forward<HyperParametersT>(value));
    return *this;
  }
  template <typename HyperParametersKeyT = Aws::String, typename HyperParametersValueT = Aws::String>
  DescribeTrainingJobResult& AddHyperParameters(HyperParametersKeyT&& key, HyperParametersValueT&& value) {
    m_hyperParametersHasBeenSet = true;
    m_hyperParameters.emplace(std::forward<HyperParametersKeyT>(key), std::forward<HyperParametersValueT>(value));
    return *this;
  }
 
 
  inline const AlgorithmSpecification& GetAlgorithmSpecification() const { return m_algorithmSpecification; }
  template <typename AlgorithmSpecificationT = AlgorithmSpecification>
  void SetAlgorithmSpecification(AlgorithmSpecificationT&& value) {
    m_algorithmSpecificationHasBeenSet = true;
    m_algorithmSpecification = std::forward<AlgorithmSpecificationT>(value);
  }
  template <typename AlgorithmSpecificationT = AlgorithmSpecification>
  DescribeTrainingJobResult& WithAlgorithmSpecification(AlgorithmSpecificationT&& value) {
    SetAlgorithmSpecification(std::forward<AlgorithmSpecificationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRoleArn() const { return m_roleArn; }
  template <typename RoleArnT = Aws::String>
  void SetRoleArn(RoleArnT&& value) {
    m_roleArnHasBeenSet = true;
    m_roleArn = std::forward<RoleArnT>(value);
  }
  template <typename RoleArnT = Aws::String>
  DescribeTrainingJobResult& WithRoleArn(RoleArnT&& value) {
    SetRoleArn(std::forward<RoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Channel>& GetInputDataConfig() const { return m_inputDataConfig; }
  template <typename InputDataConfigT = Aws::Vector<Channel>>
  void SetInputDataConfig(InputDataConfigT&& value) {
    m_inputDataConfigHasBeenSet = true;
    m_inputDataConfig = std::forward<InputDataConfigT>(value);
  }
  template <typename InputDataConfigT = Aws::Vector<Channel>>
  DescribeTrainingJobResult& WithInputDataConfig(InputDataConfigT&& value) {
    SetInputDataConfig(std::forward<InputDataConfigT>(value));
    return *this;
  }
  template <typename InputDataConfigT = Channel>
  DescribeTrainingJobResult& AddInputDataConfig(InputDataConfigT&& value) {
    m_inputDataConfigHasBeenSet = true;
    m_inputDataConfig.emplace_back(std::forward<InputDataConfigT>(value));
    return *this;
  }
 
 
  inline const OutputDataConfig& GetOutputDataConfig() const { return m_outputDataConfig; }
  template <typename OutputDataConfigT = OutputDataConfig>
  void SetOutputDataConfig(OutputDataConfigT&& value) {
    m_outputDataConfigHasBeenSet = true;
    m_outputDataConfig = std::forward<OutputDataConfigT>(value);
  }
  template <typename OutputDataConfigT = OutputDataConfig>
  DescribeTrainingJobResult& WithOutputDataConfig(OutputDataConfigT&& value) {
    SetOutputDataConfig(std::forward<OutputDataConfigT>(value));
    return *this;
  }
 
 
  inline const ResourceConfig& GetResourceConfig() const { return m_resourceConfig; }
  template <typename ResourceConfigT = ResourceConfig>
  void SetResourceConfig(ResourceConfigT&& value) {
    m_resourceConfigHasBeenSet = true;
    m_resourceConfig = std::forward<ResourceConfigT>(value);
  }
  template <typename ResourceConfigT = ResourceConfig>
  DescribeTrainingJobResult& WithResourceConfig(ResourceConfigT&& value) {
    SetResourceConfig(std::forward<ResourceConfigT>(value));
    return *this;
  }
 
 
  inline const WarmPoolStatus& GetWarmPoolStatus() const { return m_warmPoolStatus; }
  template <typename WarmPoolStatusT = WarmPoolStatus>
  void SetWarmPoolStatus(WarmPoolStatusT&& value) {
    m_warmPoolStatusHasBeenSet = true;
    m_warmPoolStatus = std::forward<WarmPoolStatusT>(value);
  }
  template <typename WarmPoolStatusT = WarmPoolStatus>
  DescribeTrainingJobResult& WithWarmPoolStatus(WarmPoolStatusT&& value) {
    SetWarmPoolStatus(std::forward<WarmPoolStatusT>(value));
    return *this;
  }
 
 
  inline const VpcConfig& GetVpcConfig() const { return m_vpcConfig; }
  template <typename VpcConfigT = VpcConfig>
  void SetVpcConfig(VpcConfigT&& value) {
    m_vpcConfigHasBeenSet = true;
    m_vpcConfig = std::forward<VpcConfigT>(value);
  }
  template <typename VpcConfigT = VpcConfig>
  DescribeTrainingJobResult& WithVpcConfig(VpcConfigT&& value) {
    SetVpcConfig(std::forward<VpcConfigT>(value));
    return *this;
  }
 
 
  inline const StoppingCondition& GetStoppingCondition() const { return m_stoppingCondition; }
  template <typename StoppingConditionT = StoppingCondition>
  void SetStoppingCondition(StoppingConditionT&& value) {
    m_stoppingConditionHasBeenSet = true;
    m_stoppingCondition = std::forward<StoppingConditionT>(value);
  }
  template <typename StoppingConditionT = StoppingCondition>
  DescribeTrainingJobResult& WithStoppingCondition(StoppingConditionT&& value) {
    SetStoppingCondition(std::forward<StoppingConditionT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreationTime() const { return m_creationTime; }
  template <typename CreationTimeT = Aws::Utils::DateTime>
  void SetCreationTime(CreationTimeT&& value) {
    m_creationTimeHasBeenSet = true;
    m_creationTime = std::forward<CreationTimeT>(value);
  }
  template <typename CreationTimeT = Aws::Utils::DateTime>
  DescribeTrainingJobResult& WithCreationTime(CreationTimeT&& value) {
    SetCreationTime(std::forward<CreationTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetTrainingStartTime() const { return m_trainingStartTime; }
  template <typename TrainingStartTimeT = Aws::Utils::DateTime>
  void SetTrainingStartTime(TrainingStartTimeT&& value) {
    m_trainingStartTimeHasBeenSet = true;
    m_trainingStartTime = std::forward<TrainingStartTimeT>(value);
  }
  template <typename TrainingStartTimeT = Aws::Utils::DateTime>
  DescribeTrainingJobResult& WithTrainingStartTime(TrainingStartTimeT&& value) {
    SetTrainingStartTime(std::forward<TrainingStartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetTrainingEndTime() const { return m_trainingEndTime; }
  template <typename TrainingEndTimeT = Aws::Utils::DateTime>
  void SetTrainingEndTime(TrainingEndTimeT&& value) {
    m_trainingEndTimeHasBeenSet = true;
    m_trainingEndTime = std::forward<TrainingEndTimeT>(value);
  }
  template <typename TrainingEndTimeT = Aws::Utils::DateTime>
  DescribeTrainingJobResult& WithTrainingEndTime(TrainingEndTimeT&& value) {
    SetTrainingEndTime(std::forward<TrainingEndTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastModifiedTime() const { return m_lastModifiedTime; }
  template <typename LastModifiedTimeT = Aws::Utils::DateTime>
  void SetLastModifiedTime(LastModifiedTimeT&& value) {
    m_lastModifiedTimeHasBeenSet = true;
    m_lastModifiedTime = std::forward<LastModifiedTimeT>(value);
  }
  template <typename LastModifiedTimeT = Aws::Utils::DateTime>
  DescribeTrainingJobResult& WithLastModifiedTime(LastModifiedTimeT&& value) {
    SetLastModifiedTime(std::forward<LastModifiedTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SecondaryStatusTransition>& GetSecondaryStatusTransitions() const { return m_secondaryStatusTransitions; }
  template <typename SecondaryStatusTransitionsT = Aws::Vector<SecondaryStatusTransition>>
  void SetSecondaryStatusTransitions(SecondaryStatusTransitionsT&& value) {
    m_secondaryStatusTransitionsHasBeenSet = true;
    m_secondaryStatusTransitions = std::forward<SecondaryStatusTransitionsT>(value);
  }
  template <typename SecondaryStatusTransitionsT = Aws::Vector<SecondaryStatusTransition>>
  DescribeTrainingJobResult& WithSecondaryStatusTransitions(SecondaryStatusTransitionsT&& value) {
    SetSecondaryStatusTransitions(std::forward<SecondaryStatusTransitionsT>(value));
    return *this;
  }
  template <typename SecondaryStatusTransitionsT = SecondaryStatusTransition>
  DescribeTrainingJobResult& AddSecondaryStatusTransitions(SecondaryStatusTransitionsT&& value) {
    m_secondaryStatusTransitionsHasBeenSet = true;
    m_secondaryStatusTransitions.emplace_back(std::forward<SecondaryStatusTransitionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<MetricData>& GetFinalMetricDataList() const { return m_finalMetricDataList; }
  template <typename FinalMetricDataListT = Aws::Vector<MetricData>>
  void SetFinalMetricDataList(FinalMetricDataListT&& value) {
    m_finalMetricDataListHasBeenSet = true;
    m_finalMetricDataList = std::forward<FinalMetricDataListT>(value);
  }
  template <typename FinalMetricDataListT = Aws::Vector<MetricData>>
  DescribeTrainingJobResult& WithFinalMetricDataList(FinalMetricDataListT&& value) {
    SetFinalMetricDataList(std::forward<FinalMetricDataListT>(value));
    return *this;
  }
  template <typename FinalMetricDataListT = MetricData>
  DescribeTrainingJobResult& AddFinalMetricDataList(FinalMetricDataListT&& value) {
    m_finalMetricDataListHasBeenSet = true;
    m_finalMetricDataList.emplace_back(std::forward<FinalMetricDataListT>(value));
    return *this;
  }
 
 
  inline bool GetEnableNetworkIsolation() const { return m_enableNetworkIsolation; }
  inline void SetEnableNetworkIsolation(bool value) {
    m_enableNetworkIsolationHasBeenSet = true;
    m_enableNetworkIsolation = value;
  }
  inline DescribeTrainingJobResult& WithEnableNetworkIsolation(bool value) {
    SetEnableNetworkIsolation(value);
    return *this;
  }
 
 
  inline bool GetEnableInterContainerTrafficEncryption() const { return m_enableInterContainerTrafficEncryption; }
  inline void SetEnableInterContainerTrafficEncryption(bool value) {
    m_enableInterContainerTrafficEncryptionHasBeenSet = true;
    m_enableInterContainerTrafficEncryption = value;
  }
  inline DescribeTrainingJobResult& WithEnableInterContainerTrafficEncryption(bool value) {
    SetEnableInterContainerTrafficEncryption(value);
    return *this;
  }
 
 
  inline bool GetEnableManagedSpotTraining() const { return m_enableManagedSpotTraining; }
  inline void SetEnableManagedSpotTraining(bool value) {
    m_enableManagedSpotTrainingHasBeenSet = true;
    m_enableManagedSpotTraining = value;
  }
  inline DescribeTrainingJobResult& WithEnableManagedSpotTraining(bool value) {
    SetEnableManagedSpotTraining(value);
    return *this;
  }
 
 
  inline const CheckpointConfig& GetCheckpointConfig() const { return m_checkpointConfig; }
  template <typename CheckpointConfigT = CheckpointConfig>
  void SetCheckpointConfig(CheckpointConfigT&& value) {
    m_checkpointConfigHasBeenSet = true;
    m_checkpointConfig = std::forward<CheckpointConfigT>(value);
  }
  template <typename CheckpointConfigT = CheckpointConfig>
  DescribeTrainingJobResult& WithCheckpointConfig(CheckpointConfigT&& value) {
    SetCheckpointConfig(std::forward<CheckpointConfigT>(value));
    return *this;
  }
 
 
  inline int GetTrainingTimeInSeconds() const { return m_trainingTimeInSeconds; }
  inline void SetTrainingTimeInSeconds(int value) {
    m_trainingTimeInSecondsHasBeenSet = true;
    m_trainingTimeInSeconds = value;
  }
  inline DescribeTrainingJobResult& WithTrainingTimeInSeconds(int value) {
    SetTrainingTimeInSeconds(value);
    return *this;
  }
 
 
  inline int GetBillableTimeInSeconds() const { return m_billableTimeInSeconds; }
  inline void SetBillableTimeInSeconds(int value) {
    m_billableTimeInSecondsHasBeenSet = true;
    m_billableTimeInSeconds = value;
  }
  inline DescribeTrainingJobResult& WithBillableTimeInSeconds(int value) {
    SetBillableTimeInSeconds(value);
    return *this;
  }
 
 
  inline long long GetBillableTokenCount() const { return m_billableTokenCount; }
  inline void SetBillableTokenCount(long long value) {
    m_billableTokenCountHasBeenSet = true;
    m_billableTokenCount = value;
  }
  inline DescribeTrainingJobResult& WithBillableTokenCount(long long value) {
    SetBillableTokenCount(value);
    return *this;
  }
 
 
  inline const DebugHookConfig& GetDebugHookConfig() const { return m_debugHookConfig; }
  template <typename DebugHookConfigT = DebugHookConfig>
  void SetDebugHookConfig(DebugHookConfigT&& value) {
    m_debugHookConfigHasBeenSet = true;
    m_debugHookConfig = std::forward<DebugHookConfigT>(value);
  }
  template <typename DebugHookConfigT = DebugHookConfig>
  DescribeTrainingJobResult& WithDebugHookConfig(DebugHookConfigT&& value) {
    SetDebugHookConfig(std::forward<DebugHookConfigT>(value));
    return *this;
  }
 
 
  inline const ExperimentConfig& GetExperimentConfig() const { return m_experimentConfig; }
  template <typename ExperimentConfigT = ExperimentConfig>
  void SetExperimentConfig(ExperimentConfigT&& value) {
    m_experimentConfigHasBeenSet = true;
    m_experimentConfig = std::forward<ExperimentConfigT>(value);
  }
  template <typename ExperimentConfigT = ExperimentConfig>
  DescribeTrainingJobResult& WithExperimentConfig(ExperimentConfigT&& value) {
    SetExperimentConfig(std::forward<ExperimentConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DebugRuleConfiguration>& GetDebugRuleConfigurations() const { return m_debugRuleConfigurations; }
  template <typename DebugRuleConfigurationsT = Aws::Vector<DebugRuleConfiguration>>
  void SetDebugRuleConfigurations(DebugRuleConfigurationsT&& value) {
    m_debugRuleConfigurationsHasBeenSet = true;
    m_debugRuleConfigurations = std::forward<DebugRuleConfigurationsT>(value);
  }
  template <typename DebugRuleConfigurationsT = Aws::Vector<DebugRuleConfiguration>>
  DescribeTrainingJobResult& WithDebugRuleConfigurations(DebugRuleConfigurationsT&& value) {
    SetDebugRuleConfigurations(std::forward<DebugRuleConfigurationsT>(value));
    return *this;
  }
  template <typename DebugRuleConfigurationsT = DebugRuleConfiguration>
  DescribeTrainingJobResult& AddDebugRuleConfigurations(DebugRuleConfigurationsT&& value) {
    m_debugRuleConfigurationsHasBeenSet = true;
    m_debugRuleConfigurations.emplace_back(std::forward<DebugRuleConfigurationsT>(value));
    return *this;
  }
 
 
  inline const TensorBoardOutputConfig& GetTensorBoardOutputConfig() const { return m_tensorBoardOutputConfig; }
  template <typename TensorBoardOutputConfigT = TensorBoardOutputConfig>
  void SetTensorBoardOutputConfig(TensorBoardOutputConfigT&& value) {
    m_tensorBoardOutputConfigHasBeenSet = true;
    m_tensorBoardOutputConfig = std::forward<TensorBoardOutputConfigT>(value);
  }
  template <typename TensorBoardOutputConfigT = TensorBoardOutputConfig>
  DescribeTrainingJobResult& WithTensorBoardOutputConfig(TensorBoardOutputConfigT&& value) {
    SetTensorBoardOutputConfig(std::forward<TensorBoardOutputConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DebugRuleEvaluationStatus>& GetDebugRuleEvaluationStatuses() const { return m_debugRuleEvaluationStatuses; }
  template <typename DebugRuleEvaluationStatusesT = Aws::Vector<DebugRuleEvaluationStatus>>
  void SetDebugRuleEvaluationStatuses(DebugRuleEvaluationStatusesT&& value) {
    m_debugRuleEvaluationStatusesHasBeenSet = true;
    m_debugRuleEvaluationStatuses = std::forward<DebugRuleEvaluationStatusesT>(value);
  }
  template <typename DebugRuleEvaluationStatusesT = Aws::Vector<DebugRuleEvaluationStatus>>
  DescribeTrainingJobResult& WithDebugRuleEvaluationStatuses(DebugRuleEvaluationStatusesT&& value) {
    SetDebugRuleEvaluationStatuses(std::forward<DebugRuleEvaluationStatusesT>(value));
    return *this;
  }
  template <typename DebugRuleEvaluationStatusesT = DebugRuleEvaluationStatus>
  DescribeTrainingJobResult& AddDebugRuleEvaluationStatuses(DebugRuleEvaluationStatusesT&& value) {
    m_debugRuleEvaluationStatusesHasBeenSet = true;
    m_debugRuleEvaluationStatuses.emplace_back(std::forward<DebugRuleEvaluationStatusesT>(value));
    return *this;
  }
 
 
  inline const ProfilerConfig& GetProfilerConfig() const { return m_profilerConfig; }
  template <typename ProfilerConfigT = ProfilerConfig>
  void SetProfilerConfig(ProfilerConfigT&& value) {
    m_profilerConfigHasBeenSet = true;
    m_profilerConfig = std::forward<ProfilerConfigT>(value);
  }
  template <typename ProfilerConfigT = ProfilerConfig>
  DescribeTrainingJobResult& WithProfilerConfig(ProfilerConfigT&& value) {
    SetProfilerConfig(std::forward<ProfilerConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ProfilerRuleConfiguration>& GetProfilerRuleConfigurations() const { return m_profilerRuleConfigurations; }
  template <typename ProfilerRuleConfigurationsT = Aws::Vector<ProfilerRuleConfiguration>>
  void SetProfilerRuleConfigurations(ProfilerRuleConfigurationsT&& value) {
    m_profilerRuleConfigurationsHasBeenSet = true;
    m_profilerRuleConfigurations = std::forward<ProfilerRuleConfigurationsT>(value);
  }
  template <typename ProfilerRuleConfigurationsT = Aws::Vector<ProfilerRuleConfiguration>>
  DescribeTrainingJobResult& WithProfilerRuleConfigurations(ProfilerRuleConfigurationsT&& value) {
    SetProfilerRuleConfigurations(std::forward<ProfilerRuleConfigurationsT>(value));
    return *this;
  }
  template <typename ProfilerRuleConfigurationsT = ProfilerRuleConfiguration>
  DescribeTrainingJobResult& AddProfilerRuleConfigurations(ProfilerRuleConfigurationsT&& value) {
    m_profilerRuleConfigurationsHasBeenSet = true;
    m_profilerRuleConfigurations.emplace_back(std::forward<ProfilerRuleConfigurationsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ProfilerRuleEvaluationStatus>& GetProfilerRuleEvaluationStatuses() const {
    return m_profilerRuleEvaluationStatuses;
  }
  template <typename ProfilerRuleEvaluationStatusesT = Aws::Vector<ProfilerRuleEvaluationStatus>>
  void SetProfilerRuleEvaluationStatuses(ProfilerRuleEvaluationStatusesT&& value) {
    m_profilerRuleEvaluationStatusesHasBeenSet = true;
    m_profilerRuleEvaluationStatuses = std::forward<ProfilerRuleEvaluationStatusesT>(value);
  }
  template <typename ProfilerRuleEvaluationStatusesT = Aws::Vector<ProfilerRuleEvaluationStatus>>
  DescribeTrainingJobResult& WithProfilerRuleEvaluationStatuses(ProfilerRuleEvaluationStatusesT&& value) {
    SetProfilerRuleEvaluationStatuses(std::forward<ProfilerRuleEvaluationStatusesT>(value));
    return *this;
  }
  template <typename ProfilerRuleEvaluationStatusesT = ProfilerRuleEvaluationStatus>
  DescribeTrainingJobResult& AddProfilerRuleEvaluationStatuses(ProfilerRuleEvaluationStatusesT&& value) {
    m_profilerRuleEvaluationStatusesHasBeenSet = true;
    m_profilerRuleEvaluationStatuses.emplace_back(std::forward<ProfilerRuleEvaluationStatusesT>(value));
    return *this;
  }
 
 
  inline ProfilingStatus GetProfilingStatus() const { return m_profilingStatus; }
  inline void SetProfilingStatus(ProfilingStatus value) {
    m_profilingStatusHasBeenSet = true;
    m_profilingStatus = value;
  }
  inline DescribeTrainingJobResult& WithProfilingStatus(ProfilingStatus value) {
    SetProfilingStatus(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetEnvironment() const { return m_environment; }
  template <typename EnvironmentT = Aws::Map<Aws::String, Aws::String>>
  void SetEnvironment(EnvironmentT&& value) {
    m_environmentHasBeenSet = true;
    m_environment = std::forward<EnvironmentT>(value);
  }
  template <typename EnvironmentT = Aws::Map<Aws::String, Aws::String>>
  DescribeTrainingJobResult& WithEnvironment(EnvironmentT&& value) {
    SetEnvironment(std::forward<EnvironmentT>(value));
    return *this;
  }
  template <typename EnvironmentKeyT = Aws::String, typename EnvironmentValueT = Aws::String>
  DescribeTrainingJobResult& AddEnvironment(EnvironmentKeyT&& key, EnvironmentValueT&& value) {
    m_environmentHasBeenSet = true;
    m_environment.emplace(std::forward<EnvironmentKeyT>(key), std::forward<EnvironmentValueT>(value));
    return *this;
  }
 
 
  inline const RetryStrategy& GetRetryStrategy() const { return m_retryStrategy; }
  template <typename RetryStrategyT = RetryStrategy>
  void SetRetryStrategy(RetryStrategyT&& value) {
    m_retryStrategyHasBeenSet = true;
    m_retryStrategy = std::forward<RetryStrategyT>(value);
  }
  template <typename RetryStrategyT = RetryStrategy>
  DescribeTrainingJobResult& WithRetryStrategy(RetryStrategyT&& value) {
    SetRetryStrategy(std::forward<RetryStrategyT>(value));
    return *this;
  }
 
 
  inline const RemoteDebugConfig& GetRemoteDebugConfig() const { return m_remoteDebugConfig; }
  template <typename RemoteDebugConfigT = RemoteDebugConfig>
  void SetRemoteDebugConfig(RemoteDebugConfigT&& value) {
    m_remoteDebugConfigHasBeenSet = true;
    m_remoteDebugConfig = std::forward<RemoteDebugConfigT>(value);
  }
  template <typename RemoteDebugConfigT = RemoteDebugConfig>
  DescribeTrainingJobResult& WithRemoteDebugConfig(RemoteDebugConfigT&& value) {
    SetRemoteDebugConfig(std::forward<RemoteDebugConfigT>(value));
    return *this;
  }
 
 
  inline const InfraCheckConfig& GetInfraCheckConfig() const { return m_infraCheckConfig; }
  template <typename InfraCheckConfigT = InfraCheckConfig>
  void SetInfraCheckConfig(InfraCheckConfigT&& value) {
    m_infraCheckConfigHasBeenSet = true;
    m_infraCheckConfig = std::forward<InfraCheckConfigT>(value);
  }
  template <typename InfraCheckConfigT = InfraCheckConfig>
  DescribeTrainingJobResult& WithInfraCheckConfig(InfraCheckConfigT&& value) {
    SetInfraCheckConfig(std::forward<InfraCheckConfigT>(value));
    return *this;
  }
 
 
  inline const ServerlessJobConfig& GetServerlessJobConfig() const { return m_serverlessJobConfig; }
  template <typename ServerlessJobConfigT = ServerlessJobConfig>
  void SetServerlessJobConfig(ServerlessJobConfigT&& value) {
    m_serverlessJobConfigHasBeenSet = true;
    m_serverlessJobConfig = std::forward<ServerlessJobConfigT>(value);
  }
  template <typename ServerlessJobConfigT = ServerlessJobConfig>
  DescribeTrainingJobResult& WithServerlessJobConfig(ServerlessJobConfigT&& value) {
    SetServerlessJobConfig(std::forward<ServerlessJobConfigT>(value));
    return *this;
  }
 
 
  inline const MlflowConfig& GetMlflowConfig() const { return m_mlflowConfig; }
  template <typename MlflowConfigT = MlflowConfig>
  void SetMlflowConfig(MlflowConfigT&& value) {
    m_mlflowConfigHasBeenSet = true;
    m_mlflowConfig = std::forward<MlflowConfigT>(value);
  }
  template <typename MlflowConfigT = MlflowConfig>
  DescribeTrainingJobResult& WithMlflowConfig(MlflowConfigT&& value) {
    SetMlflowConfig(std::forward<MlflowConfigT>(value));
    return *this;
  }
 
 
  inline const ModelPackageConfig& GetModelPackageConfig() const { return m_modelPackageConfig; }
  template <typename ModelPackageConfigT = ModelPackageConfig>
  void SetModelPackageConfig(ModelPackageConfigT&& value) {
    m_modelPackageConfigHasBeenSet = true;
    m_modelPackageConfig = std::forward<ModelPackageConfigT>(value);
  }
  template <typename ModelPackageConfigT = ModelPackageConfig>
  DescribeTrainingJobResult& WithModelPackageConfig(ModelPackageConfigT&& value) {
    SetModelPackageConfig(std::forward<ModelPackageConfigT>(value));
    return *this;
  }
 
 
  inline const MlflowDetails& GetMlflowDetails() const { return m_mlflowDetails; }
  template <typename MlflowDetailsT = MlflowDetails>
  void SetMlflowDetails(MlflowDetailsT&& value) {
    m_mlflowDetailsHasBeenSet = true;
    m_mlflowDetails = std::forward<MlflowDetailsT>(value);
  }
  template <typename MlflowDetailsT = MlflowDetails>
  DescribeTrainingJobResult& WithMlflowDetails(MlflowDetailsT&& value) {
    SetMlflowDetails(std::forward<MlflowDetailsT>(value));
    return *this;
  }
 
 
  inline const TrainingProgressInfo& GetProgressInfo() const { return m_progressInfo; }
  template <typename ProgressInfoT = TrainingProgressInfo>
  void SetProgressInfo(ProgressInfoT&& value) {
    m_progressInfoHasBeenSet = true;
    m_progressInfo = std::forward<ProgressInfoT>(value);
  }
  template <typename ProgressInfoT = TrainingProgressInfo>
  DescribeTrainingJobResult& WithProgressInfo(ProgressInfoT&& value) {
    SetProgressInfo(std::forward<ProgressInfoT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOutputModelPackageArn() const { return m_outputModelPackageArn; }
  template <typename OutputModelPackageArnT = Aws::String>
  void SetOutputModelPackageArn(OutputModelPackageArnT&& value) {
    m_outputModelPackageArnHasBeenSet = true;
    m_outputModelPackageArn = std::forward<OutputModelPackageArnT>(value);
  }
  template <typename OutputModelPackageArnT = Aws::String>
  DescribeTrainingJobResult& WithOutputModelPackageArn(OutputModelPackageArnT&& value) {
    SetOutputModelPackageArn(std::forward<OutputModelPackageArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  DescribeTrainingJobResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
  inline Aws::Http::HttpResponseCode GetHttpResponseCode() const { return m_HttpResponseCode; }
 
 private:
  Aws::String m_trainingJobName;
 
  Aws::String m_trainingJobArn;
 
  Aws::String m_tuningJobArn;
 
  Aws::String m_labelingJobArn;
 
  Aws::String m_autoMLJobArn;
 
  ModelArtifacts m_modelArtifacts;
 
  TrainingJobStatus m_trainingJobStatus{TrainingJobStatus::NOT_SET};
 
  SecondaryStatus m_secondaryStatus{SecondaryStatus::NOT_SET};
 
  Aws::String m_failureReason;
 
  Aws::Map<Aws::String, Aws::String> m_hyperParameters;
 
  AlgorithmSpecification m_algorithmSpecification;
 
  Aws::String m_roleArn;
 
  Aws::Vector<Channel> m_inputDataConfig;
 
  OutputDataConfig m_outputDataConfig;
 
  ResourceConfig m_resourceConfig;
 
  WarmPoolStatus m_warmPoolStatus;
 
  VpcConfig m_vpcConfig;
 
  StoppingCondition m_stoppingCondition;
 
  Aws::Utils::DateTime m_creationTime{};
 
  Aws::Utils::DateTime m_trainingStartTime{};
 
  Aws::Utils::DateTime m_trainingEndTime{};
 
  Aws::Utils::DateTime m_lastModifiedTime{};
 
  Aws::Vector<SecondaryStatusTransition> m_secondaryStatusTransitions;
 
  Aws::Vector<MetricData> m_finalMetricDataList;
 
  bool m_enableNetworkIsolation{false};
 
  bool m_enableInterContainerTrafficEncryption{false};
 
  bool m_enableManagedSpotTraining{false};
 
  CheckpointConfig m_checkpointConfig;
 
  int m_trainingTimeInSeconds{0};
 
  int m_billableTimeInSeconds{0};
 
  long long m_billableTokenCount{0};
 
  DebugHookConfig m_debugHookConfig;
 
  ExperimentConfig m_experimentConfig;
 
  Aws::Vector<DebugRuleConfiguration> m_debugRuleConfigurations;
 
  TensorBoardOutputConfig m_tensorBoardOutputConfig;
 
  Aws::Vector<DebugRuleEvaluationStatus> m_debugRuleEvaluationStatuses;
 
  ProfilerConfig m_profilerConfig;
 
  Aws::Vector<ProfilerRuleConfiguration> m_profilerRuleConfigurations;
 
  Aws::Vector<ProfilerRuleEvaluationStatus> m_profilerRuleEvaluationStatuses;
 
  ProfilingStatus m_profilingStatus{ProfilingStatus::NOT_SET};
 
  Aws::Map<Aws::String, Aws::String> m_environment;
 
  RetryStrategy m_retryStrategy;
 
  RemoteDebugConfig m_remoteDebugConfig;
 
  InfraCheckConfig m_infraCheckConfig;
 
  ServerlessJobConfig m_serverlessJobConfig;
 
  MlflowConfig m_mlflowConfig;
 
  ModelPackageConfig m_modelPackageConfig;
 
  MlflowDetails m_mlflowDetails;
 
  TrainingProgressInfo m_progressInfo;
 
  Aws::String m_outputModelPackageArn;
 
  Aws::String m_requestId;
  Aws::Http::HttpResponseCode m_HttpResponseCode;
  bool m_trainingJobNameHasBeenSet = false;
  bool m_trainingJobArnHasBeenSet = false;
  bool m_tuningJobArnHasBeenSet = false;
  bool m_labelingJobArnHasBeenSet = false;
  bool m_autoMLJobArnHasBeenSet = false;
  bool m_modelArtifactsHasBeenSet = false;
  bool m_trainingJobStatusHasBeenSet = false;
  bool m_secondaryStatusHasBeenSet = false;
  bool m_failureReasonHasBeenSet = false;
  bool m_hyperParametersHasBeenSet = false;
  bool m_algorithmSpecificationHasBeenSet = false;
  bool m_roleArnHasBeenSet = false;
  bool m_inputDataConfigHasBeenSet = false;
  bool m_outputDataConfigHasBeenSet = false;
  bool m_resourceConfigHasBeenSet = false;
  bool m_warmPoolStatusHasBeenSet = false;
  bool m_vpcConfigHasBeenSet = false;
  bool m_stoppingConditionHasBeenSet = false;
  bool m_creationTimeHasBeenSet = false;
  bool m_trainingStartTimeHasBeenSet = false;
  bool m_trainingEndTimeHasBeenSet = false;
  bool m_lastModifiedTimeHasBeenSet = false;
  bool m_secondaryStatusTransitionsHasBeenSet = false;
  bool m_finalMetricDataListHasBeenSet = false;
  bool m_enableNetworkIsolationHasBeenSet = false;
  bool m_enableInterContainerTrafficEncryptionHasBeenSet = false;
  bool m_enableManagedSpotTrainingHasBeenSet = false;
  bool m_checkpointConfigHasBeenSet = false;
  bool m_trainingTimeInSecondsHasBeenSet = false;
  bool m_billableTimeInSecondsHasBeenSet = false;
  bool m_billableTokenCountHasBeenSet = false;
  bool m_debugHookConfigHasBeenSet = false;
  bool m_experimentConfigHasBeenSet = false;
  bool m_debugRuleConfigurationsHasBeenSet = false;
  bool m_tensorBoardOutputConfigHasBeenSet = false;
  bool m_debugRuleEvaluationStatusesHasBeenSet = false;
  bool m_profilerConfigHasBeenSet = false;
  bool m_profilerRuleConfigurationsHasBeenSet = false;
  bool m_profilerRuleEvaluationStatusesHasBeenSet = false;
  bool m_profilingStatusHasBeenSet = false;
  bool m_environmentHasBeenSet = false;
  bool m_retryStrategyHasBeenSet = false;
  bool m_remoteDebugConfigHasBeenSet = false;
  bool m_infraCheckConfigHasBeenSet = false;
  bool m_serverlessJobConfigHasBeenSet = false;
  bool m_mlflowConfigHasBeenSet = false;
  bool m_modelPackageConfigHasBeenSet = false;
  bool m_mlflowDetailsHasBeenSet = false;
  bool m_progressInfoHasBeenSet = false;
  bool m_outputModelPackageArnHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SageMaker
}  // namespace Aws