GetModelCustomizationJobResult.h

 
#pragma once
#include <aws/bedrock/Bedrock_EXPORTS.h>
#include <aws/bedrock/model/CustomizationConfig.h>
#include <aws/bedrock/model/CustomizationType.h>
#include <aws/bedrock/model/ModelCustomizationJobStatus.h>
#include <aws/bedrock/model/OutputDataConfig.h>
#include <aws/bedrock/model/StatusDetails.h>
#include <aws/bedrock/model/TrainingDataConfig.h>
#include <aws/bedrock/model/TrainingMetrics.h>
#include <aws/bedrock/model/ValidationDataConfig.h>
#include <aws/bedrock/model/ValidatorMetric.h>
#include <aws/bedrock/model/VpcConfig.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 <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace Bedrock {
namespace Model {
class GetModelCustomizationJobResult {
 public:
  AWS_BEDROCK_API GetModelCustomizationJobResult() = default;
  AWS_BEDROCK_API GetModelCustomizationJobResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_BEDROCK_API GetModelCustomizationJobResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetJobArn() const { return m_jobArn; }
  template <typename JobArnT = Aws::String>
  void SetJobArn(JobArnT&& value) {
    m_jobArnHasBeenSet = true;
    m_jobArn = std::forward<JobArnT>(value);
  }
  template <typename JobArnT = Aws::String>
  GetModelCustomizationJobResult& WithJobArn(JobArnT&& value) {
    SetJobArn(std::forward<JobArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetJobName() const { return m_jobName; }
  template <typename JobNameT = Aws::String>
  void SetJobName(JobNameT&& value) {
    m_jobNameHasBeenSet = true;
    m_jobName = std::forward<JobNameT>(value);
  }
  template <typename JobNameT = Aws::String>
  GetModelCustomizationJobResult& WithJobName(JobNameT&& value) {
    SetJobName(std::forward<JobNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOutputModelName() const { return m_outputModelName; }
  template <typename OutputModelNameT = Aws::String>
  void SetOutputModelName(OutputModelNameT&& value) {
    m_outputModelNameHasBeenSet = true;
    m_outputModelName = std::forward<OutputModelNameT>(value);
  }
  template <typename OutputModelNameT = Aws::String>
  GetModelCustomizationJobResult& WithOutputModelName(OutputModelNameT&& value) {
    SetOutputModelName(std::forward<OutputModelNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOutputModelArn() const { return m_outputModelArn; }
  template <typename OutputModelArnT = Aws::String>
  void SetOutputModelArn(OutputModelArnT&& value) {
    m_outputModelArnHasBeenSet = true;
    m_outputModelArn = std::forward<OutputModelArnT>(value);
  }
  template <typename OutputModelArnT = Aws::String>
  GetModelCustomizationJobResult& WithOutputModelArn(OutputModelArnT&& value) {
    SetOutputModelArn(std::forward<OutputModelArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClientRequestToken() const { return m_clientRequestToken; }
  template <typename ClientRequestTokenT = Aws::String>
  void SetClientRequestToken(ClientRequestTokenT&& value) {
    m_clientRequestTokenHasBeenSet = true;
    m_clientRequestToken = std::forward<ClientRequestTokenT>(value);
  }
  template <typename ClientRequestTokenT = Aws::String>
  GetModelCustomizationJobResult& WithClientRequestToken(ClientRequestTokenT&& value) {
    SetClientRequestToken(std::forward<ClientRequestTokenT>(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>
  GetModelCustomizationJobResult& WithRoleArn(RoleArnT&& value) {
    SetRoleArn(std::forward<RoleArnT>(value));
    return *this;
  }
 
 
  inline ModelCustomizationJobStatus GetStatus() const { return m_status; }
  inline void SetStatus(ModelCustomizationJobStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline GetModelCustomizationJobResult& WithStatus(ModelCustomizationJobStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const StatusDetails& GetStatusDetails() const { return m_statusDetails; }
  template <typename StatusDetailsT = StatusDetails>
  void SetStatusDetails(StatusDetailsT&& value) {
    m_statusDetailsHasBeenSet = true;
    m_statusDetails = std::forward<StatusDetailsT>(value);
  }
  template <typename StatusDetailsT = StatusDetails>
  GetModelCustomizationJobResult& WithStatusDetails(StatusDetailsT&& value) {
    SetStatusDetails(std::forward<StatusDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFailureMessage() const { return m_failureMessage; }
  template <typename FailureMessageT = Aws::String>
  void SetFailureMessage(FailureMessageT&& value) {
    m_failureMessageHasBeenSet = true;
    m_failureMessage = std::forward<FailureMessageT>(value);
  }
  template <typename FailureMessageT = Aws::String>
  GetModelCustomizationJobResult& WithFailureMessage(FailureMessageT&& value) {
    SetFailureMessage(std::forward<FailureMessageT>(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>
  GetModelCustomizationJobResult& WithCreationTime(CreationTimeT&& value) {
    SetCreationTime(std::forward<CreationTimeT>(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>
  GetModelCustomizationJobResult& WithLastModifiedTime(LastModifiedTimeT&& value) {
    SetLastModifiedTime(std::forward<LastModifiedTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetEndTime() const { return m_endTime; }
  template <typename EndTimeT = Aws::Utils::DateTime>
  void SetEndTime(EndTimeT&& value) {
    m_endTimeHasBeenSet = true;
    m_endTime = std::forward<EndTimeT>(value);
  }
  template <typename EndTimeT = Aws::Utils::DateTime>
  GetModelCustomizationJobResult& WithEndTime(EndTimeT&& value) {
    SetEndTime(std::forward<EndTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBaseModelArn() const { return m_baseModelArn; }
  template <typename BaseModelArnT = Aws::String>
  void SetBaseModelArn(BaseModelArnT&& value) {
    m_baseModelArnHasBeenSet = true;
    m_baseModelArn = std::forward<BaseModelArnT>(value);
  }
  template <typename BaseModelArnT = Aws::String>
  GetModelCustomizationJobResult& WithBaseModelArn(BaseModelArnT&& value) {
    SetBaseModelArn(std::forward<BaseModelArnT>(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>>
  GetModelCustomizationJobResult& WithHyperParameters(HyperParametersT&& value) {
    SetHyperParameters(std::forward<HyperParametersT>(value));
    return *this;
  }
  template <typename HyperParametersKeyT = Aws::String, typename HyperParametersValueT = Aws::String>
  GetModelCustomizationJobResult& AddHyperParameters(HyperParametersKeyT&& key, HyperParametersValueT&& value) {
    m_hyperParametersHasBeenSet = true;
    m_hyperParameters.emplace(std::forward<HyperParametersKeyT>(key), std::forward<HyperParametersValueT>(value));
    return *this;
  }
 
 
  inline const TrainingDataConfig& GetTrainingDataConfig() const { return m_trainingDataConfig; }
  template <typename TrainingDataConfigT = TrainingDataConfig>
  void SetTrainingDataConfig(TrainingDataConfigT&& value) {
    m_trainingDataConfigHasBeenSet = true;
    m_trainingDataConfig = std::forward<TrainingDataConfigT>(value);
  }
  template <typename TrainingDataConfigT = TrainingDataConfig>
  GetModelCustomizationJobResult& WithTrainingDataConfig(TrainingDataConfigT&& value) {
    SetTrainingDataConfig(std::forward<TrainingDataConfigT>(value));
    return *this;
  }
 
 
  inline const ValidationDataConfig& GetValidationDataConfig() const { return m_validationDataConfig; }
  template <typename ValidationDataConfigT = ValidationDataConfig>
  void SetValidationDataConfig(ValidationDataConfigT&& value) {
    m_validationDataConfigHasBeenSet = true;
    m_validationDataConfig = std::forward<ValidationDataConfigT>(value);
  }
  template <typename ValidationDataConfigT = ValidationDataConfig>
  GetModelCustomizationJobResult& WithValidationDataConfig(ValidationDataConfigT&& value) {
    SetValidationDataConfig(std::forward<ValidationDataConfigT>(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>
  GetModelCustomizationJobResult& WithOutputDataConfig(OutputDataConfigT&& value) {
    SetOutputDataConfig(std::forward<OutputDataConfigT>(value));
    return *this;
  }
 
 
  inline CustomizationType GetCustomizationType() const { return m_customizationType; }
  inline void SetCustomizationType(CustomizationType value) {
    m_customizationTypeHasBeenSet = true;
    m_customizationType = value;
  }
  inline GetModelCustomizationJobResult& WithCustomizationType(CustomizationType value) {
    SetCustomizationType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetOutputModelKmsKeyArn() const { return m_outputModelKmsKeyArn; }
  template <typename OutputModelKmsKeyArnT = Aws::String>
  void SetOutputModelKmsKeyArn(OutputModelKmsKeyArnT&& value) {
    m_outputModelKmsKeyArnHasBeenSet = true;
    m_outputModelKmsKeyArn = std::forward<OutputModelKmsKeyArnT>(value);
  }
  template <typename OutputModelKmsKeyArnT = Aws::String>
  GetModelCustomizationJobResult& WithOutputModelKmsKeyArn(OutputModelKmsKeyArnT&& value) {
    SetOutputModelKmsKeyArn(std::forward<OutputModelKmsKeyArnT>(value));
    return *this;
  }
 
 
  inline const TrainingMetrics& GetTrainingMetrics() const { return m_trainingMetrics; }
  template <typename TrainingMetricsT = TrainingMetrics>
  void SetTrainingMetrics(TrainingMetricsT&& value) {
    m_trainingMetricsHasBeenSet = true;
    m_trainingMetrics = std::forward<TrainingMetricsT>(value);
  }
  template <typename TrainingMetricsT = TrainingMetrics>
  GetModelCustomizationJobResult& WithTrainingMetrics(TrainingMetricsT&& value) {
    SetTrainingMetrics(std::forward<TrainingMetricsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ValidatorMetric>& GetValidationMetrics() const { return m_validationMetrics; }
  template <typename ValidationMetricsT = Aws::Vector<ValidatorMetric>>
  void SetValidationMetrics(ValidationMetricsT&& value) {
    m_validationMetricsHasBeenSet = true;
    m_validationMetrics = std::forward<ValidationMetricsT>(value);
  }
  template <typename ValidationMetricsT = Aws::Vector<ValidatorMetric>>
  GetModelCustomizationJobResult& WithValidationMetrics(ValidationMetricsT&& value) {
    SetValidationMetrics(std::forward<ValidationMetricsT>(value));
    return *this;
  }
  template <typename ValidationMetricsT = ValidatorMetric>
  GetModelCustomizationJobResult& AddValidationMetrics(ValidationMetricsT&& value) {
    m_validationMetricsHasBeenSet = true;
    m_validationMetrics.emplace_back(std::forward<ValidationMetricsT>(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>
  GetModelCustomizationJobResult& WithVpcConfig(VpcConfigT&& value) {
    SetVpcConfig(std::forward<VpcConfigT>(value));
    return *this;
  }
 
 
  inline const CustomizationConfig& GetCustomizationConfig() const { return m_customizationConfig; }
  template <typename CustomizationConfigT = CustomizationConfig>
  void SetCustomizationConfig(CustomizationConfigT&& value) {
    m_customizationConfigHasBeenSet = true;
    m_customizationConfig = std::forward<CustomizationConfigT>(value);
  }
  template <typename CustomizationConfigT = CustomizationConfig>
  GetModelCustomizationJobResult& WithCustomizationConfig(CustomizationConfigT&& value) {
    SetCustomizationConfig(std::forward<CustomizationConfigT>(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>
  GetModelCustomizationJobResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
 private:
  Aws::String m_jobArn;
 
  Aws::String m_jobName;
 
  Aws::String m_outputModelName;
 
  Aws::String m_outputModelArn;
 
  Aws::String m_clientRequestToken;
 
  Aws::String m_roleArn;
 
  ModelCustomizationJobStatus m_status{ModelCustomizationJobStatus::NOT_SET};
 
  StatusDetails m_statusDetails;
 
  Aws::String m_failureMessage;
 
  Aws::Utils::DateTime m_creationTime{};
 
  Aws::Utils::DateTime m_lastModifiedTime{};
 
  Aws::Utils::DateTime m_endTime{};
 
  Aws::String m_baseModelArn;
 
  Aws::Map<Aws::String, Aws::String> m_hyperParameters;
 
  TrainingDataConfig m_trainingDataConfig;
 
  ValidationDataConfig m_validationDataConfig;
 
  OutputDataConfig m_outputDataConfig;
 
  CustomizationType m_customizationType{CustomizationType::NOT_SET};
 
  Aws::String m_outputModelKmsKeyArn;
 
  TrainingMetrics m_trainingMetrics;
 
  Aws::Vector<ValidatorMetric> m_validationMetrics;
 
  VpcConfig m_vpcConfig;
 
  CustomizationConfig m_customizationConfig;
 
  Aws::String m_requestId;
  bool m_jobArnHasBeenSet = false;
  bool m_jobNameHasBeenSet = false;
  bool m_outputModelNameHasBeenSet = false;
  bool m_outputModelArnHasBeenSet = false;
  bool m_clientRequestTokenHasBeenSet = false;
  bool m_roleArnHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_statusDetailsHasBeenSet = false;
  bool m_failureMessageHasBeenSet = false;
  bool m_creationTimeHasBeenSet = false;
  bool m_lastModifiedTimeHasBeenSet = false;
  bool m_endTimeHasBeenSet = false;
  bool m_baseModelArnHasBeenSet = false;
  bool m_hyperParametersHasBeenSet = false;
  bool m_trainingDataConfigHasBeenSet = false;
  bool m_validationDataConfigHasBeenSet = false;
  bool m_outputDataConfigHasBeenSet = false;
  bool m_customizationTypeHasBeenSet = false;
  bool m_outputModelKmsKeyArnHasBeenSet = false;
  bool m_trainingMetricsHasBeenSet = false;
  bool m_validationMetricsHasBeenSet = false;
  bool m_vpcConfigHasBeenSet = false;
  bool m_customizationConfigHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Bedrock
}  // namespace Aws