CreateModelCustomizationJobRequest.h

 
#pragma once
#include <aws/bedrock/BedrockRequest.h>
#include <aws/bedrock/Bedrock_EXPORTS.h>
#include <aws/bedrock/model/CustomizationConfig.h>
#include <aws/bedrock/model/CustomizationType.h>
#include <aws/bedrock/model/OutputDataConfig.h>
#include <aws/bedrock/model/Tag.h>
#include <aws/bedrock/model/TrainingDataConfig.h>
#include <aws/bedrock/model/ValidationDataConfig.h>
#include <aws/bedrock/model/VpcConfig.h>
#include <aws/core/utils/UUID.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 {
namespace Bedrock {
namespace Model {
 
class CreateModelCustomizationJobRequest : public BedrockRequest {
 public:
  AWS_BEDROCK_API CreateModelCustomizationJobRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "CreateModelCustomizationJob"; }
 
  AWS_BEDROCK_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetJobName() const { return m_jobName; }
  inline bool JobNameHasBeenSet() const { return m_jobNameHasBeenSet; }
  template <typename JobNameT = Aws::String>
  void SetJobName(JobNameT&& value) {
    m_jobNameHasBeenSet = true;
    m_jobName = std::forward<JobNameT>(value);
  }
  template <typename JobNameT = Aws::String>
  CreateModelCustomizationJobRequest& WithJobName(JobNameT&& value) {
    SetJobName(std::forward<JobNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCustomModelName() const { return m_customModelName; }
  inline bool CustomModelNameHasBeenSet() const { return m_customModelNameHasBeenSet; }
  template <typename CustomModelNameT = Aws::String>
  void SetCustomModelName(CustomModelNameT&& value) {
    m_customModelNameHasBeenSet = true;
    m_customModelName = std::forward<CustomModelNameT>(value);
  }
  template <typename CustomModelNameT = Aws::String>
  CreateModelCustomizationJobRequest& WithCustomModelName(CustomModelNameT&& value) {
    SetCustomModelName(std::forward<CustomModelNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRoleArn() const { return m_roleArn; }
  inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
  template <typename RoleArnT = Aws::String>
  void SetRoleArn(RoleArnT&& value) {
    m_roleArnHasBeenSet = true;
    m_roleArn = std::forward<RoleArnT>(value);
  }
  template <typename RoleArnT = Aws::String>
  CreateModelCustomizationJobRequest& WithRoleArn(RoleArnT&& value) {
    SetRoleArn(std::forward<RoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClientRequestToken() const { return m_clientRequestToken; }
  inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
  template <typename ClientRequestTokenT = Aws::String>
  void SetClientRequestToken(ClientRequestTokenT&& value) {
    m_clientRequestTokenHasBeenSet = true;
    m_clientRequestToken = std::forward<ClientRequestTokenT>(value);
  }
  template <typename ClientRequestTokenT = Aws::String>
  CreateModelCustomizationJobRequest& WithClientRequestToken(ClientRequestTokenT&& value) {
    SetClientRequestToken(std::forward<ClientRequestTokenT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBaseModelIdentifier() const { return m_baseModelIdentifier; }
  inline bool BaseModelIdentifierHasBeenSet() const { return m_baseModelIdentifierHasBeenSet; }
  template <typename BaseModelIdentifierT = Aws::String>
  void SetBaseModelIdentifier(BaseModelIdentifierT&& value) {
    m_baseModelIdentifierHasBeenSet = true;
    m_baseModelIdentifier = std::forward<BaseModelIdentifierT>(value);
  }
  template <typename BaseModelIdentifierT = Aws::String>
  CreateModelCustomizationJobRequest& WithBaseModelIdentifier(BaseModelIdentifierT&& value) {
    SetBaseModelIdentifier(std::forward<BaseModelIdentifierT>(value));
    return *this;
  }
 
 
  inline CustomizationType GetCustomizationType() const { return m_customizationType; }
  inline bool CustomizationTypeHasBeenSet() const { return m_customizationTypeHasBeenSet; }
  inline void SetCustomizationType(CustomizationType value) {
    m_customizationTypeHasBeenSet = true;
    m_customizationType = value;
  }
  inline CreateModelCustomizationJobRequest& WithCustomizationType(CustomizationType value) {
    SetCustomizationType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetCustomModelKmsKeyId() const { return m_customModelKmsKeyId; }
  inline bool CustomModelKmsKeyIdHasBeenSet() const { return m_customModelKmsKeyIdHasBeenSet; }
  template <typename CustomModelKmsKeyIdT = Aws::String>
  void SetCustomModelKmsKeyId(CustomModelKmsKeyIdT&& value) {
    m_customModelKmsKeyIdHasBeenSet = true;
    m_customModelKmsKeyId = std::forward<CustomModelKmsKeyIdT>(value);
  }
  template <typename CustomModelKmsKeyIdT = Aws::String>
  CreateModelCustomizationJobRequest& WithCustomModelKmsKeyId(CustomModelKmsKeyIdT&& value) {
    SetCustomModelKmsKeyId(std::forward<CustomModelKmsKeyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetJobTags() const { return m_jobTags; }
  inline bool JobTagsHasBeenSet() const { return m_jobTagsHasBeenSet; }
  template <typename JobTagsT = Aws::Vector<Tag>>
  void SetJobTags(JobTagsT&& value) {
    m_jobTagsHasBeenSet = true;
    m_jobTags = std::forward<JobTagsT>(value);
  }
  template <typename JobTagsT = Aws::Vector<Tag>>
  CreateModelCustomizationJobRequest& WithJobTags(JobTagsT&& value) {
    SetJobTags(std::forward<JobTagsT>(value));
    return *this;
  }
  template <typename JobTagsT = Tag>
  CreateModelCustomizationJobRequest& AddJobTags(JobTagsT&& value) {
    m_jobTagsHasBeenSet = true;
    m_jobTags.emplace_back(std::forward<JobTagsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetCustomModelTags() const { return m_customModelTags; }
  inline bool CustomModelTagsHasBeenSet() const { return m_customModelTagsHasBeenSet; }
  template <typename CustomModelTagsT = Aws::Vector<Tag>>
  void SetCustomModelTags(CustomModelTagsT&& value) {
    m_customModelTagsHasBeenSet = true;
    m_customModelTags = std::forward<CustomModelTagsT>(value);
  }
  template <typename CustomModelTagsT = Aws::Vector<Tag>>
  CreateModelCustomizationJobRequest& WithCustomModelTags(CustomModelTagsT&& value) {
    SetCustomModelTags(std::forward<CustomModelTagsT>(value));
    return *this;
  }
  template <typename CustomModelTagsT = Tag>
  CreateModelCustomizationJobRequest& AddCustomModelTags(CustomModelTagsT&& value) {
    m_customModelTagsHasBeenSet = true;
    m_customModelTags.emplace_back(std::forward<CustomModelTagsT>(value));
    return *this;
  }
 
 
  inline const TrainingDataConfig& GetTrainingDataConfig() const { return m_trainingDataConfig; }
  inline bool TrainingDataConfigHasBeenSet() const { return m_trainingDataConfigHasBeenSet; }
  template <typename TrainingDataConfigT = TrainingDataConfig>
  void SetTrainingDataConfig(TrainingDataConfigT&& value) {
    m_trainingDataConfigHasBeenSet = true;
    m_trainingDataConfig = std::forward<TrainingDataConfigT>(value);
  }
  template <typename TrainingDataConfigT = TrainingDataConfig>
  CreateModelCustomizationJobRequest& WithTrainingDataConfig(TrainingDataConfigT&& value) {
    SetTrainingDataConfig(std::forward<TrainingDataConfigT>(value));
    return *this;
  }
 
 
  inline const ValidationDataConfig& GetValidationDataConfig() const { return m_validationDataConfig; }
  inline bool ValidationDataConfigHasBeenSet() const { return m_validationDataConfigHasBeenSet; }
  template <typename ValidationDataConfigT = ValidationDataConfig>
  void SetValidationDataConfig(ValidationDataConfigT&& value) {
    m_validationDataConfigHasBeenSet = true;
    m_validationDataConfig = std::forward<ValidationDataConfigT>(value);
  }
  template <typename ValidationDataConfigT = ValidationDataConfig>
  CreateModelCustomizationJobRequest& WithValidationDataConfig(ValidationDataConfigT&& value) {
    SetValidationDataConfig(std::forward<ValidationDataConfigT>(value));
    return *this;
  }
 
 
  inline const OutputDataConfig& GetOutputDataConfig() const { return m_outputDataConfig; }
  inline bool OutputDataConfigHasBeenSet() const { return m_outputDataConfigHasBeenSet; }
  template <typename OutputDataConfigT = OutputDataConfig>
  void SetOutputDataConfig(OutputDataConfigT&& value) {
    m_outputDataConfigHasBeenSet = true;
    m_outputDataConfig = std::forward<OutputDataConfigT>(value);
  }
  template <typename OutputDataConfigT = OutputDataConfig>
  CreateModelCustomizationJobRequest& WithOutputDataConfig(OutputDataConfigT&& value) {
    SetOutputDataConfig(std::forward<OutputDataConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetHyperParameters() const { return m_hyperParameters; }
  inline bool HyperParametersHasBeenSet() const { return m_hyperParametersHasBeenSet; }
  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>>
  CreateModelCustomizationJobRequest& WithHyperParameters(HyperParametersT&& value) {
    SetHyperParameters(std::forward<HyperParametersT>(value));
    return *this;
  }
  template <typename HyperParametersKeyT = Aws::String, typename HyperParametersValueT = Aws::String>
  CreateModelCustomizationJobRequest& AddHyperParameters(HyperParametersKeyT&& key, HyperParametersValueT&& value) {
    m_hyperParametersHasBeenSet = true;
    m_hyperParameters.emplace(std::forward<HyperParametersKeyT>(key), std::forward<HyperParametersValueT>(value));
    return *this;
  }
 
 
  inline const VpcConfig& GetVpcConfig() const { return m_vpcConfig; }
  inline bool VpcConfigHasBeenSet() const { return m_vpcConfigHasBeenSet; }
  template <typename VpcConfigT = VpcConfig>
  void SetVpcConfig(VpcConfigT&& value) {
    m_vpcConfigHasBeenSet = true;
    m_vpcConfig = std::forward<VpcConfigT>(value);
  }
  template <typename VpcConfigT = VpcConfig>
  CreateModelCustomizationJobRequest& WithVpcConfig(VpcConfigT&& value) {
    SetVpcConfig(std::forward<VpcConfigT>(value));
    return *this;
  }
 
 
  inline const CustomizationConfig& GetCustomizationConfig() const { return m_customizationConfig; }
  inline bool CustomizationConfigHasBeenSet() const { return m_customizationConfigHasBeenSet; }
  template <typename CustomizationConfigT = CustomizationConfig>
  void SetCustomizationConfig(CustomizationConfigT&& value) {
    m_customizationConfigHasBeenSet = true;
    m_customizationConfig = std::forward<CustomizationConfigT>(value);
  }
  template <typename CustomizationConfigT = CustomizationConfig>
  CreateModelCustomizationJobRequest& WithCustomizationConfig(CustomizationConfigT&& value) {
    SetCustomizationConfig(std::forward<CustomizationConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_jobName;
 
  Aws::String m_customModelName;
 
  Aws::String m_roleArn;
 
  Aws::String m_clientRequestToken{Aws::Utils::UUID::PseudoRandomUUID()};
 
  Aws::String m_baseModelIdentifier;
 
  CustomizationType m_customizationType{CustomizationType::NOT_SET};
 
  Aws::String m_customModelKmsKeyId;
 
  Aws::Vector<Tag> m_jobTags;
 
  Aws::Vector<Tag> m_customModelTags;
 
  TrainingDataConfig m_trainingDataConfig;
 
  ValidationDataConfig m_validationDataConfig;
 
  OutputDataConfig m_outputDataConfig;
 
  Aws::Map<Aws::String, Aws::String> m_hyperParameters;
 
  VpcConfig m_vpcConfig;
 
  CustomizationConfig m_customizationConfig;
  bool m_jobNameHasBeenSet = false;
  bool m_customModelNameHasBeenSet = false;
  bool m_roleArnHasBeenSet = false;
  bool m_clientRequestTokenHasBeenSet = true;
  bool m_baseModelIdentifierHasBeenSet = false;
  bool m_customizationTypeHasBeenSet = false;
  bool m_customModelKmsKeyIdHasBeenSet = false;
  bool m_jobTagsHasBeenSet = false;
  bool m_customModelTagsHasBeenSet = false;
  bool m_trainingDataConfigHasBeenSet = false;
  bool m_validationDataConfigHasBeenSet = false;
  bool m_outputDataConfigHasBeenSet = false;
  bool m_hyperParametersHasBeenSet = false;
  bool m_vpcConfigHasBeenSet = false;
  bool m_customizationConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Bedrock
}  // namespace Aws