StartBuildRequest.h

 
#pragma once
#include <aws/codebuild/CodeBuildRequest.h>
#include <aws/codebuild/CodeBuild_EXPORTS.h>
#include <aws/codebuild/model/BuildStatusConfig.h>
#include <aws/codebuild/model/ComputeType.h>
#include <aws/codebuild/model/EnvironmentType.h>
#include <aws/codebuild/model/EnvironmentVariable.h>
#include <aws/codebuild/model/GitSubmodulesConfig.h>
#include <aws/codebuild/model/ImagePullCredentialsType.h>
#include <aws/codebuild/model/LogsConfig.h>
#include <aws/codebuild/model/ProjectArtifacts.h>
#include <aws/codebuild/model/ProjectCache.h>
#include <aws/codebuild/model/ProjectFleet.h>
#include <aws/codebuild/model/ProjectSource.h>
#include <aws/codebuild/model/ProjectSourceVersion.h>
#include <aws/codebuild/model/RegistryCredential.h>
#include <aws/codebuild/model/SourceAuth.h>
#include <aws/codebuild/model/SourceType.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace CodeBuild {
namespace Model {
 
class StartBuildRequest : public CodeBuildRequest {
 public:
  AWS_CODEBUILD_API StartBuildRequest() = 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 "StartBuild"; }
 
  AWS_CODEBUILD_API Aws::String SerializePayload() const override;
 
  AWS_CODEBUILD_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline const Aws::String& GetProjectName() const { return m_projectName; }
  inline bool ProjectNameHasBeenSet() const { return m_projectNameHasBeenSet; }
  template <typename ProjectNameT = Aws::String>
  void SetProjectName(ProjectNameT&& value) {
    m_projectNameHasBeenSet = true;
    m_projectName = std::forward<ProjectNameT>(value);
  }
  template <typename ProjectNameT = Aws::String>
  StartBuildRequest& WithProjectName(ProjectNameT&& value) {
    SetProjectName(std::forward<ProjectNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ProjectSource>& GetSecondarySourcesOverride() const { return m_secondarySourcesOverride; }
  inline bool SecondarySourcesOverrideHasBeenSet() const { return m_secondarySourcesOverrideHasBeenSet; }
  template <typename SecondarySourcesOverrideT = Aws::Vector<ProjectSource>>
  void SetSecondarySourcesOverride(SecondarySourcesOverrideT&& value) {
    m_secondarySourcesOverrideHasBeenSet = true;
    m_secondarySourcesOverride = std::forward<SecondarySourcesOverrideT>(value);
  }
  template <typename SecondarySourcesOverrideT = Aws::Vector<ProjectSource>>
  StartBuildRequest& WithSecondarySourcesOverride(SecondarySourcesOverrideT&& value) {
    SetSecondarySourcesOverride(std::forward<SecondarySourcesOverrideT>(value));
    return *this;
  }
  template <typename SecondarySourcesOverrideT = ProjectSource>
  StartBuildRequest& AddSecondarySourcesOverride(SecondarySourcesOverrideT&& value) {
    m_secondarySourcesOverrideHasBeenSet = true;
    m_secondarySourcesOverride.emplace_back(std::forward<SecondarySourcesOverrideT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ProjectSourceVersion>& GetSecondarySourcesVersionOverride() const { return m_secondarySourcesVersionOverride; }
  inline bool SecondarySourcesVersionOverrideHasBeenSet() const { return m_secondarySourcesVersionOverrideHasBeenSet; }
  template <typename SecondarySourcesVersionOverrideT = Aws::Vector<ProjectSourceVersion>>
  void SetSecondarySourcesVersionOverride(SecondarySourcesVersionOverrideT&& value) {
    m_secondarySourcesVersionOverrideHasBeenSet = true;
    m_secondarySourcesVersionOverride = std::forward<SecondarySourcesVersionOverrideT>(value);
  }
  template <typename SecondarySourcesVersionOverrideT = Aws::Vector<ProjectSourceVersion>>
  StartBuildRequest& WithSecondarySourcesVersionOverride(SecondarySourcesVersionOverrideT&& value) {
    SetSecondarySourcesVersionOverride(std::forward<SecondarySourcesVersionOverrideT>(value));
    return *this;
  }
  template <typename SecondarySourcesVersionOverrideT = ProjectSourceVersion>
  StartBuildRequest& AddSecondarySourcesVersionOverride(SecondarySourcesVersionOverrideT&& value) {
    m_secondarySourcesVersionOverrideHasBeenSet = true;
    m_secondarySourcesVersionOverride.emplace_back(std::forward<SecondarySourcesVersionOverrideT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSourceVersion() const { return m_sourceVersion; }
  inline bool SourceVersionHasBeenSet() const { return m_sourceVersionHasBeenSet; }
  template <typename SourceVersionT = Aws::String>
  void SetSourceVersion(SourceVersionT&& value) {
    m_sourceVersionHasBeenSet = true;
    m_sourceVersion = std::forward<SourceVersionT>(value);
  }
  template <typename SourceVersionT = Aws::String>
  StartBuildRequest& WithSourceVersion(SourceVersionT&& value) {
    SetSourceVersion(std::forward<SourceVersionT>(value));
    return *this;
  }
 
 
  inline const ProjectArtifacts& GetArtifactsOverride() const { return m_artifactsOverride; }
  inline bool ArtifactsOverrideHasBeenSet() const { return m_artifactsOverrideHasBeenSet; }
  template <typename ArtifactsOverrideT = ProjectArtifacts>
  void SetArtifactsOverride(ArtifactsOverrideT&& value) {
    m_artifactsOverrideHasBeenSet = true;
    m_artifactsOverride = std::forward<ArtifactsOverrideT>(value);
  }
  template <typename ArtifactsOverrideT = ProjectArtifacts>
  StartBuildRequest& WithArtifactsOverride(ArtifactsOverrideT&& value) {
    SetArtifactsOverride(std::forward<ArtifactsOverrideT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ProjectArtifacts>& GetSecondaryArtifactsOverride() const { return m_secondaryArtifactsOverride; }
  inline bool SecondaryArtifactsOverrideHasBeenSet() const { return m_secondaryArtifactsOverrideHasBeenSet; }
  template <typename SecondaryArtifactsOverrideT = Aws::Vector<ProjectArtifacts>>
  void SetSecondaryArtifactsOverride(SecondaryArtifactsOverrideT&& value) {
    m_secondaryArtifactsOverrideHasBeenSet = true;
    m_secondaryArtifactsOverride = std::forward<SecondaryArtifactsOverrideT>(value);
  }
  template <typename SecondaryArtifactsOverrideT = Aws::Vector<ProjectArtifacts>>
  StartBuildRequest& WithSecondaryArtifactsOverride(SecondaryArtifactsOverrideT&& value) {
    SetSecondaryArtifactsOverride(std::forward<SecondaryArtifactsOverrideT>(value));
    return *this;
  }
  template <typename SecondaryArtifactsOverrideT = ProjectArtifacts>
  StartBuildRequest& AddSecondaryArtifactsOverride(SecondaryArtifactsOverrideT&& value) {
    m_secondaryArtifactsOverrideHasBeenSet = true;
    m_secondaryArtifactsOverride.emplace_back(std::forward<SecondaryArtifactsOverrideT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<EnvironmentVariable>& GetEnvironmentVariablesOverride() const { return m_environmentVariablesOverride; }
  inline bool EnvironmentVariablesOverrideHasBeenSet() const { return m_environmentVariablesOverrideHasBeenSet; }
  template <typename EnvironmentVariablesOverrideT = Aws::Vector<EnvironmentVariable>>
  void SetEnvironmentVariablesOverride(EnvironmentVariablesOverrideT&& value) {
    m_environmentVariablesOverrideHasBeenSet = true;
    m_environmentVariablesOverride = std::forward<EnvironmentVariablesOverrideT>(value);
  }
  template <typename EnvironmentVariablesOverrideT = Aws::Vector<EnvironmentVariable>>
  StartBuildRequest& WithEnvironmentVariablesOverride(EnvironmentVariablesOverrideT&& value) {
    SetEnvironmentVariablesOverride(std::forward<EnvironmentVariablesOverrideT>(value));
    return *this;
  }
  template <typename EnvironmentVariablesOverrideT = EnvironmentVariable>
  StartBuildRequest& AddEnvironmentVariablesOverride(EnvironmentVariablesOverrideT&& value) {
    m_environmentVariablesOverrideHasBeenSet = true;
    m_environmentVariablesOverride.emplace_back(std::forward<EnvironmentVariablesOverrideT>(value));
    return *this;
  }
 
 
  inline SourceType GetSourceTypeOverride() const { return m_sourceTypeOverride; }
  inline bool SourceTypeOverrideHasBeenSet() const { return m_sourceTypeOverrideHasBeenSet; }
  inline void SetSourceTypeOverride(SourceType value) {
    m_sourceTypeOverrideHasBeenSet = true;
    m_sourceTypeOverride = value;
  }
  inline StartBuildRequest& WithSourceTypeOverride(SourceType value) {
    SetSourceTypeOverride(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSourceLocationOverride() const { return m_sourceLocationOverride; }
  inline bool SourceLocationOverrideHasBeenSet() const { return m_sourceLocationOverrideHasBeenSet; }
  template <typename SourceLocationOverrideT = Aws::String>
  void SetSourceLocationOverride(SourceLocationOverrideT&& value) {
    m_sourceLocationOverrideHasBeenSet = true;
    m_sourceLocationOverride = std::forward<SourceLocationOverrideT>(value);
  }
  template <typename SourceLocationOverrideT = Aws::String>
  StartBuildRequest& WithSourceLocationOverride(SourceLocationOverrideT&& value) {
    SetSourceLocationOverride(std::forward<SourceLocationOverrideT>(value));
    return *this;
  }
 
 
  inline const SourceAuth& GetSourceAuthOverride() const { return m_sourceAuthOverride; }
  inline bool SourceAuthOverrideHasBeenSet() const { return m_sourceAuthOverrideHasBeenSet; }
  template <typename SourceAuthOverrideT = SourceAuth>
  void SetSourceAuthOverride(SourceAuthOverrideT&& value) {
    m_sourceAuthOverrideHasBeenSet = true;
    m_sourceAuthOverride = std::forward<SourceAuthOverrideT>(value);
  }
  template <typename SourceAuthOverrideT = SourceAuth>
  StartBuildRequest& WithSourceAuthOverride(SourceAuthOverrideT&& value) {
    SetSourceAuthOverride(std::forward<SourceAuthOverrideT>(value));
    return *this;
  }
 
 
  inline int GetGitCloneDepthOverride() const { return m_gitCloneDepthOverride; }
  inline bool GitCloneDepthOverrideHasBeenSet() const { return m_gitCloneDepthOverrideHasBeenSet; }
  inline void SetGitCloneDepthOverride(int value) {
    m_gitCloneDepthOverrideHasBeenSet = true;
    m_gitCloneDepthOverride = value;
  }
  inline StartBuildRequest& WithGitCloneDepthOverride(int value) {
    SetGitCloneDepthOverride(value);
    return *this;
  }
 
 
  inline const GitSubmodulesConfig& GetGitSubmodulesConfigOverride() const { return m_gitSubmodulesConfigOverride; }
  inline bool GitSubmodulesConfigOverrideHasBeenSet() const { return m_gitSubmodulesConfigOverrideHasBeenSet; }
  template <typename GitSubmodulesConfigOverrideT = GitSubmodulesConfig>
  void SetGitSubmodulesConfigOverride(GitSubmodulesConfigOverrideT&& value) {
    m_gitSubmodulesConfigOverrideHasBeenSet = true;
    m_gitSubmodulesConfigOverride = std::forward<GitSubmodulesConfigOverrideT>(value);
  }
  template <typename GitSubmodulesConfigOverrideT = GitSubmodulesConfig>
  StartBuildRequest& WithGitSubmodulesConfigOverride(GitSubmodulesConfigOverrideT&& value) {
    SetGitSubmodulesConfigOverride(std::forward<GitSubmodulesConfigOverrideT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBuildspecOverride() const { return m_buildspecOverride; }
  inline bool BuildspecOverrideHasBeenSet() const { return m_buildspecOverrideHasBeenSet; }
  template <typename BuildspecOverrideT = Aws::String>
  void SetBuildspecOverride(BuildspecOverrideT&& value) {
    m_buildspecOverrideHasBeenSet = true;
    m_buildspecOverride = std::forward<BuildspecOverrideT>(value);
  }
  template <typename BuildspecOverrideT = Aws::String>
  StartBuildRequest& WithBuildspecOverride(BuildspecOverrideT&& value) {
    SetBuildspecOverride(std::forward<BuildspecOverrideT>(value));
    return *this;
  }
 
 
  inline bool GetInsecureSslOverride() const { return m_insecureSslOverride; }
  inline bool InsecureSslOverrideHasBeenSet() const { return m_insecureSslOverrideHasBeenSet; }
  inline void SetInsecureSslOverride(bool value) {
    m_insecureSslOverrideHasBeenSet = true;
    m_insecureSslOverride = value;
  }
  inline StartBuildRequest& WithInsecureSslOverride(bool value) {
    SetInsecureSslOverride(value);
    return *this;
  }
 
 
  inline bool GetReportBuildStatusOverride() const { return m_reportBuildStatusOverride; }
  inline bool ReportBuildStatusOverrideHasBeenSet() const { return m_reportBuildStatusOverrideHasBeenSet; }
  inline void SetReportBuildStatusOverride(bool value) {
    m_reportBuildStatusOverrideHasBeenSet = true;
    m_reportBuildStatusOverride = value;
  }
  inline StartBuildRequest& WithReportBuildStatusOverride(bool value) {
    SetReportBuildStatusOverride(value);
    return *this;
  }
 
 
  inline const BuildStatusConfig& GetBuildStatusConfigOverride() const { return m_buildStatusConfigOverride; }
  inline bool BuildStatusConfigOverrideHasBeenSet() const { return m_buildStatusConfigOverrideHasBeenSet; }
  template <typename BuildStatusConfigOverrideT = BuildStatusConfig>
  void SetBuildStatusConfigOverride(BuildStatusConfigOverrideT&& value) {
    m_buildStatusConfigOverrideHasBeenSet = true;
    m_buildStatusConfigOverride = std::forward<BuildStatusConfigOverrideT>(value);
  }
  template <typename BuildStatusConfigOverrideT = BuildStatusConfig>
  StartBuildRequest& WithBuildStatusConfigOverride(BuildStatusConfigOverrideT&& value) {
    SetBuildStatusConfigOverride(std::forward<BuildStatusConfigOverrideT>(value));
    return *this;
  }
 
 
  inline EnvironmentType GetEnvironmentTypeOverride() const { return m_environmentTypeOverride; }
  inline bool EnvironmentTypeOverrideHasBeenSet() const { return m_environmentTypeOverrideHasBeenSet; }
  inline void SetEnvironmentTypeOverride(EnvironmentType value) {
    m_environmentTypeOverrideHasBeenSet = true;
    m_environmentTypeOverride = value;
  }
  inline StartBuildRequest& WithEnvironmentTypeOverride(EnvironmentType value) {
    SetEnvironmentTypeOverride(value);
    return *this;
  }
 
 
  inline const Aws::String& GetImageOverride() const { return m_imageOverride; }
  inline bool ImageOverrideHasBeenSet() const { return m_imageOverrideHasBeenSet; }
  template <typename ImageOverrideT = Aws::String>
  void SetImageOverride(ImageOverrideT&& value) {
    m_imageOverrideHasBeenSet = true;
    m_imageOverride = std::forward<ImageOverrideT>(value);
  }
  template <typename ImageOverrideT = Aws::String>
  StartBuildRequest& WithImageOverride(ImageOverrideT&& value) {
    SetImageOverride(std::forward<ImageOverrideT>(value));
    return *this;
  }
 
 
  inline ComputeType GetComputeTypeOverride() const { return m_computeTypeOverride; }
  inline bool ComputeTypeOverrideHasBeenSet() const { return m_computeTypeOverrideHasBeenSet; }
  inline void SetComputeTypeOverride(ComputeType value) {
    m_computeTypeOverrideHasBeenSet = true;
    m_computeTypeOverride = value;
  }
  inline StartBuildRequest& WithComputeTypeOverride(ComputeType value) {
    SetComputeTypeOverride(value);
    return *this;
  }
 
 
  inline const Aws::String& GetCertificateOverride() const { return m_certificateOverride; }
  inline bool CertificateOverrideHasBeenSet() const { return m_certificateOverrideHasBeenSet; }
  template <typename CertificateOverrideT = Aws::String>
  void SetCertificateOverride(CertificateOverrideT&& value) {
    m_certificateOverrideHasBeenSet = true;
    m_certificateOverride = std::forward<CertificateOverrideT>(value);
  }
  template <typename CertificateOverrideT = Aws::String>
  StartBuildRequest& WithCertificateOverride(CertificateOverrideT&& value) {
    SetCertificateOverride(std::forward<CertificateOverrideT>(value));
    return *this;
  }
 
 
  inline const ProjectCache& GetCacheOverride() const { return m_cacheOverride; }
  inline bool CacheOverrideHasBeenSet() const { return m_cacheOverrideHasBeenSet; }
  template <typename CacheOverrideT = ProjectCache>
  void SetCacheOverride(CacheOverrideT&& value) {
    m_cacheOverrideHasBeenSet = true;
    m_cacheOverride = std::forward<CacheOverrideT>(value);
  }
  template <typename CacheOverrideT = ProjectCache>
  StartBuildRequest& WithCacheOverride(CacheOverrideT&& value) {
    SetCacheOverride(std::forward<CacheOverrideT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServiceRoleOverride() const { return m_serviceRoleOverride; }
  inline bool ServiceRoleOverrideHasBeenSet() const { return m_serviceRoleOverrideHasBeenSet; }
  template <typename ServiceRoleOverrideT = Aws::String>
  void SetServiceRoleOverride(ServiceRoleOverrideT&& value) {
    m_serviceRoleOverrideHasBeenSet = true;
    m_serviceRoleOverride = std::forward<ServiceRoleOverrideT>(value);
  }
  template <typename ServiceRoleOverrideT = Aws::String>
  StartBuildRequest& WithServiceRoleOverride(ServiceRoleOverrideT&& value) {
    SetServiceRoleOverride(std::forward<ServiceRoleOverrideT>(value));
    return *this;
  }
 
 
  inline bool GetPrivilegedModeOverride() const { return m_privilegedModeOverride; }
  inline bool PrivilegedModeOverrideHasBeenSet() const { return m_privilegedModeOverrideHasBeenSet; }
  inline void SetPrivilegedModeOverride(bool value) {
    m_privilegedModeOverrideHasBeenSet = true;
    m_privilegedModeOverride = value;
  }
  inline StartBuildRequest& WithPrivilegedModeOverride(bool value) {
    SetPrivilegedModeOverride(value);
    return *this;
  }
 
 
  inline int GetTimeoutInMinutesOverride() const { return m_timeoutInMinutesOverride; }
  inline bool TimeoutInMinutesOverrideHasBeenSet() const { return m_timeoutInMinutesOverrideHasBeenSet; }
  inline void SetTimeoutInMinutesOverride(int value) {
    m_timeoutInMinutesOverrideHasBeenSet = true;
    m_timeoutInMinutesOverride = value;
  }
  inline StartBuildRequest& WithTimeoutInMinutesOverride(int value) {
    SetTimeoutInMinutesOverride(value);
    return *this;
  }
 
 
  inline int GetQueuedTimeoutInMinutesOverride() const { return m_queuedTimeoutInMinutesOverride; }
  inline bool QueuedTimeoutInMinutesOverrideHasBeenSet() const { return m_queuedTimeoutInMinutesOverrideHasBeenSet; }
  inline void SetQueuedTimeoutInMinutesOverride(int value) {
    m_queuedTimeoutInMinutesOverrideHasBeenSet = true;
    m_queuedTimeoutInMinutesOverride = value;
  }
  inline StartBuildRequest& WithQueuedTimeoutInMinutesOverride(int value) {
    SetQueuedTimeoutInMinutesOverride(value);
    return *this;
  }
 
 
  inline const Aws::String& GetEncryptionKeyOverride() const { return m_encryptionKeyOverride; }
  inline bool EncryptionKeyOverrideHasBeenSet() const { return m_encryptionKeyOverrideHasBeenSet; }
  template <typename EncryptionKeyOverrideT = Aws::String>
  void SetEncryptionKeyOverride(EncryptionKeyOverrideT&& value) {
    m_encryptionKeyOverrideHasBeenSet = true;
    m_encryptionKeyOverride = std::forward<EncryptionKeyOverrideT>(value);
  }
  template <typename EncryptionKeyOverrideT = Aws::String>
  StartBuildRequest& WithEncryptionKeyOverride(EncryptionKeyOverrideT&& value) {
    SetEncryptionKeyOverride(std::forward<EncryptionKeyOverrideT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIdempotencyToken() const { return m_idempotencyToken; }
  inline bool IdempotencyTokenHasBeenSet() const { return m_idempotencyTokenHasBeenSet; }
  template <typename IdempotencyTokenT = Aws::String>
  void SetIdempotencyToken(IdempotencyTokenT&& value) {
    m_idempotencyTokenHasBeenSet = true;
    m_idempotencyToken = std::forward<IdempotencyTokenT>(value);
  }
  template <typename IdempotencyTokenT = Aws::String>
  StartBuildRequest& WithIdempotencyToken(IdempotencyTokenT&& value) {
    SetIdempotencyToken(std::forward<IdempotencyTokenT>(value));
    return *this;
  }
 
 
  inline const LogsConfig& GetLogsConfigOverride() const { return m_logsConfigOverride; }
  inline bool LogsConfigOverrideHasBeenSet() const { return m_logsConfigOverrideHasBeenSet; }
  template <typename LogsConfigOverrideT = LogsConfig>
  void SetLogsConfigOverride(LogsConfigOverrideT&& value) {
    m_logsConfigOverrideHasBeenSet = true;
    m_logsConfigOverride = std::forward<LogsConfigOverrideT>(value);
  }
  template <typename LogsConfigOverrideT = LogsConfig>
  StartBuildRequest& WithLogsConfigOverride(LogsConfigOverrideT&& value) {
    SetLogsConfigOverride(std::forward<LogsConfigOverrideT>(value));
    return *this;
  }
 
 
  inline const RegistryCredential& GetRegistryCredentialOverride() const { return m_registryCredentialOverride; }
  inline bool RegistryCredentialOverrideHasBeenSet() const { return m_registryCredentialOverrideHasBeenSet; }
  template <typename RegistryCredentialOverrideT = RegistryCredential>
  void SetRegistryCredentialOverride(RegistryCredentialOverrideT&& value) {
    m_registryCredentialOverrideHasBeenSet = true;
    m_registryCredentialOverride = std::forward<RegistryCredentialOverrideT>(value);
  }
  template <typename RegistryCredentialOverrideT = RegistryCredential>
  StartBuildRequest& WithRegistryCredentialOverride(RegistryCredentialOverrideT&& value) {
    SetRegistryCredentialOverride(std::forward<RegistryCredentialOverrideT>(value));
    return *this;
  }
 
 
  inline ImagePullCredentialsType GetImagePullCredentialsTypeOverride() const { return m_imagePullCredentialsTypeOverride; }
  inline bool ImagePullCredentialsTypeOverrideHasBeenSet() const { return m_imagePullCredentialsTypeOverrideHasBeenSet; }
  inline void SetImagePullCredentialsTypeOverride(ImagePullCredentialsType value) {
    m_imagePullCredentialsTypeOverrideHasBeenSet = true;
    m_imagePullCredentialsTypeOverride = value;
  }
  inline StartBuildRequest& WithImagePullCredentialsTypeOverride(ImagePullCredentialsType value) {
    SetImagePullCredentialsTypeOverride(value);
    return *this;
  }
 
 
  inline bool GetDebugSessionEnabled() const { return m_debugSessionEnabled; }
  inline bool DebugSessionEnabledHasBeenSet() const { return m_debugSessionEnabledHasBeenSet; }
  inline void SetDebugSessionEnabled(bool value) {
    m_debugSessionEnabledHasBeenSet = true;
    m_debugSessionEnabled = value;
  }
  inline StartBuildRequest& WithDebugSessionEnabled(bool value) {
    SetDebugSessionEnabled(value);
    return *this;
  }
 
 
  inline const ProjectFleet& GetFleetOverride() const { return m_fleetOverride; }
  inline bool FleetOverrideHasBeenSet() const { return m_fleetOverrideHasBeenSet; }
  template <typename FleetOverrideT = ProjectFleet>
  void SetFleetOverride(FleetOverrideT&& value) {
    m_fleetOverrideHasBeenSet = true;
    m_fleetOverride = std::forward<FleetOverrideT>(value);
  }
  template <typename FleetOverrideT = ProjectFleet>
  StartBuildRequest& WithFleetOverride(FleetOverrideT&& value) {
    SetFleetOverride(std::forward<FleetOverrideT>(value));
    return *this;
  }
 
 
  inline int GetAutoRetryLimitOverride() const { return m_autoRetryLimitOverride; }
  inline bool AutoRetryLimitOverrideHasBeenSet() const { return m_autoRetryLimitOverrideHasBeenSet; }
  inline void SetAutoRetryLimitOverride(int value) {
    m_autoRetryLimitOverrideHasBeenSet = true;
    m_autoRetryLimitOverride = value;
  }
  inline StartBuildRequest& WithAutoRetryLimitOverride(int value) {
    SetAutoRetryLimitOverride(value);
    return *this;
  }
 private:
  Aws::String m_projectName;
 
  Aws::Vector<ProjectSource> m_secondarySourcesOverride;
 
  Aws::Vector<ProjectSourceVersion> m_secondarySourcesVersionOverride;
 
  Aws::String m_sourceVersion;
 
  ProjectArtifacts m_artifactsOverride;
 
  Aws::Vector<ProjectArtifacts> m_secondaryArtifactsOverride;
 
  Aws::Vector<EnvironmentVariable> m_environmentVariablesOverride;
 
  SourceType m_sourceTypeOverride{SourceType::NOT_SET};
 
  Aws::String m_sourceLocationOverride;
 
  SourceAuth m_sourceAuthOverride;
 
  int m_gitCloneDepthOverride{0};
 
  GitSubmodulesConfig m_gitSubmodulesConfigOverride;
 
  Aws::String m_buildspecOverride;
 
  bool m_insecureSslOverride{false};
 
  bool m_reportBuildStatusOverride{false};
 
  BuildStatusConfig m_buildStatusConfigOverride;
 
  EnvironmentType m_environmentTypeOverride{EnvironmentType::NOT_SET};
 
  Aws::String m_imageOverride;
 
  ComputeType m_computeTypeOverride{ComputeType::NOT_SET};
 
  Aws::String m_certificateOverride;
 
  ProjectCache m_cacheOverride;
 
  Aws::String m_serviceRoleOverride;
 
  bool m_privilegedModeOverride{false};
 
  int m_timeoutInMinutesOverride{0};
 
  int m_queuedTimeoutInMinutesOverride{0};
 
  Aws::String m_encryptionKeyOverride;
 
  Aws::String m_idempotencyToken;
 
  LogsConfig m_logsConfigOverride;
 
  RegistryCredential m_registryCredentialOverride;
 
  ImagePullCredentialsType m_imagePullCredentialsTypeOverride{ImagePullCredentialsType::NOT_SET};
 
  bool m_debugSessionEnabled{false};
 
  ProjectFleet m_fleetOverride;
 
  int m_autoRetryLimitOverride{0};
  bool m_projectNameHasBeenSet = false;
  bool m_secondarySourcesOverrideHasBeenSet = false;
  bool m_secondarySourcesVersionOverrideHasBeenSet = false;
  bool m_sourceVersionHasBeenSet = false;
  bool m_artifactsOverrideHasBeenSet = false;
  bool m_secondaryArtifactsOverrideHasBeenSet = false;
  bool m_environmentVariablesOverrideHasBeenSet = false;
  bool m_sourceTypeOverrideHasBeenSet = false;
  bool m_sourceLocationOverrideHasBeenSet = false;
  bool m_sourceAuthOverrideHasBeenSet = false;
  bool m_gitCloneDepthOverrideHasBeenSet = false;
  bool m_gitSubmodulesConfigOverrideHasBeenSet = false;
  bool m_buildspecOverrideHasBeenSet = false;
  bool m_insecureSslOverrideHasBeenSet = false;
  bool m_reportBuildStatusOverrideHasBeenSet = false;
  bool m_buildStatusConfigOverrideHasBeenSet = false;
  bool m_environmentTypeOverrideHasBeenSet = false;
  bool m_imageOverrideHasBeenSet = false;
  bool m_computeTypeOverrideHasBeenSet = false;
  bool m_certificateOverrideHasBeenSet = false;
  bool m_cacheOverrideHasBeenSet = false;
  bool m_serviceRoleOverrideHasBeenSet = false;
  bool m_privilegedModeOverrideHasBeenSet = false;
  bool m_timeoutInMinutesOverrideHasBeenSet = false;
  bool m_queuedTimeoutInMinutesOverrideHasBeenSet = false;
  bool m_encryptionKeyOverrideHasBeenSet = false;
  bool m_idempotencyTokenHasBeenSet = false;
  bool m_logsConfigOverrideHasBeenSet = false;
  bool m_registryCredentialOverrideHasBeenSet = false;
  bool m_imagePullCredentialsTypeOverrideHasBeenSet = false;
  bool m_debugSessionEnabledHasBeenSet = false;
  bool m_fleetOverrideHasBeenSet = false;
  bool m_autoRetryLimitOverrideHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CodeBuild
}  // namespace Aws