CreateCustomModelRequest.h

 
#pragma once
#include <aws/bedrock/BedrockRequest.h>
#include <aws/bedrock/Bedrock_EXPORTS.h>
#include <aws/bedrock/model/CustomModelDataSource.h>
#include <aws/bedrock/model/ModelDataSource.h>
#include <aws/bedrock/model/Tag.h>
#include <aws/core/utils/UUID.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 CreateCustomModelRequest : public BedrockRequest {
 public:
  AWS_BEDROCK_API CreateCustomModelRequest() = 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 "CreateCustomModel"; }
 
  AWS_BEDROCK_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetModelName() const { return m_modelName; }
  inline bool ModelNameHasBeenSet() const { return m_modelNameHasBeenSet; }
  template <typename ModelNameT = Aws::String>
  void SetModelName(ModelNameT&& value) {
    m_modelNameHasBeenSet = true;
    m_modelName = std::forward<ModelNameT>(value);
  }
  template <typename ModelNameT = Aws::String>
  CreateCustomModelRequest& WithModelName(ModelNameT&& value) {
    SetModelName(std::forward<ModelNameT>(value));
    return *this;
  }
 
 
  inline const ModelDataSource& GetModelSourceConfig() const { return m_modelSourceConfig; }
  inline bool ModelSourceConfigHasBeenSet() const { return m_modelSourceConfigHasBeenSet; }
  template <typename ModelSourceConfigT = ModelDataSource>
  void SetModelSourceConfig(ModelSourceConfigT&& value) {
    m_modelSourceConfigHasBeenSet = true;
    m_modelSourceConfig = std::forward<ModelSourceConfigT>(value);
  }
  template <typename ModelSourceConfigT = ModelDataSource>
  CreateCustomModelRequest& WithModelSourceConfig(ModelSourceConfigT&& value) {
    SetModelSourceConfig(std::forward<ModelSourceConfigT>(value));
    return *this;
  }
 
 
  inline const CustomModelDataSource& GetCustomModelDataSource() const { return m_customModelDataSource; }
  inline bool CustomModelDataSourceHasBeenSet() const { return m_customModelDataSourceHasBeenSet; }
  template <typename CustomModelDataSourceT = CustomModelDataSource>
  void SetCustomModelDataSource(CustomModelDataSourceT&& value) {
    m_customModelDataSourceHasBeenSet = true;
    m_customModelDataSource = std::forward<CustomModelDataSourceT>(value);
  }
  template <typename CustomModelDataSourceT = CustomModelDataSource>
  CreateCustomModelRequest& WithCustomModelDataSource(CustomModelDataSourceT&& value) {
    SetCustomModelDataSource(std::forward<CustomModelDataSourceT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetModelKmsKeyArn() const { return m_modelKmsKeyArn; }
  inline bool ModelKmsKeyArnHasBeenSet() const { return m_modelKmsKeyArnHasBeenSet; }
  template <typename ModelKmsKeyArnT = Aws::String>
  void SetModelKmsKeyArn(ModelKmsKeyArnT&& value) {
    m_modelKmsKeyArnHasBeenSet = true;
    m_modelKmsKeyArn = std::forward<ModelKmsKeyArnT>(value);
  }
  template <typename ModelKmsKeyArnT = Aws::String>
  CreateCustomModelRequest& WithModelKmsKeyArn(ModelKmsKeyArnT&& value) {
    SetModelKmsKeyArn(std::forward<ModelKmsKeyArnT>(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>
  CreateCustomModelRequest& WithRoleArn(RoleArnT&& value) {
    SetRoleArn(std::forward<RoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetModelTags() const { return m_modelTags; }
  inline bool ModelTagsHasBeenSet() const { return m_modelTagsHasBeenSet; }
  template <typename ModelTagsT = Aws::Vector<Tag>>
  void SetModelTags(ModelTagsT&& value) {
    m_modelTagsHasBeenSet = true;
    m_modelTags = std::forward<ModelTagsT>(value);
  }
  template <typename ModelTagsT = Aws::Vector<Tag>>
  CreateCustomModelRequest& WithModelTags(ModelTagsT&& value) {
    SetModelTags(std::forward<ModelTagsT>(value));
    return *this;
  }
  template <typename ModelTagsT = Tag>
  CreateCustomModelRequest& AddModelTags(ModelTagsT&& value) {
    m_modelTagsHasBeenSet = true;
    m_modelTags.emplace_back(std::forward<ModelTagsT>(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>
  CreateCustomModelRequest& WithClientRequestToken(ClientRequestTokenT&& value) {
    SetClientRequestToken(std::forward<ClientRequestTokenT>(value));
    return *this;
  }
 private:
  Aws::String m_modelName;
 
  ModelDataSource m_modelSourceConfig;
 
  CustomModelDataSource m_customModelDataSource;
 
  Aws::String m_modelKmsKeyArn;
 
  Aws::String m_roleArn;
 
  Aws::Vector<Tag> m_modelTags;
 
  Aws::String m_clientRequestToken{Aws::Utils::UUID::PseudoRandomUUID()};
  bool m_modelNameHasBeenSet = false;
  bool m_modelSourceConfigHasBeenSet = false;
  bool m_customModelDataSourceHasBeenSet = false;
  bool m_modelKmsKeyArnHasBeenSet = false;
  bool m_roleArnHasBeenSet = false;
  bool m_modelTagsHasBeenSet = false;
  bool m_clientRequestTokenHasBeenSet = true;
};
 
}  // namespace Model
}  // namespace Bedrock
}  // namespace Aws