{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.CodeBuild.UpdateProject
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Changes the settings of a build project.
module Amazonka.CodeBuild.UpdateProject
  ( -- * Creating a Request
    UpdateProject (..),
    newUpdateProject,

    -- * Request Lenses
    updateProject_secondaryArtifacts,
    updateProject_artifacts,
    updateProject_environment,
    updateProject_concurrentBuildLimit,
    updateProject_badgeEnabled,
    updateProject_secondarySourceVersions,
    updateProject_queuedTimeoutInMinutes,
    updateProject_cache,
    updateProject_secondarySources,
    updateProject_sourceVersion,
    updateProject_vpcConfig,
    updateProject_source,
    updateProject_logsConfig,
    updateProject_fileSystemLocations,
    updateProject_buildBatchConfig,
    updateProject_encryptionKey,
    updateProject_description,
    updateProject_serviceRole,
    updateProject_tags,
    updateProject_timeoutInMinutes,
    updateProject_name,

    -- * Destructuring the Response
    UpdateProjectResponse (..),
    newUpdateProjectResponse,

    -- * Response Lenses
    updateProjectResponse_project,
    updateProjectResponse_httpStatus,
  )
where

import Amazonka.CodeBuild.Types
import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newUpdateProject' smart constructor.
data UpdateProject = UpdateProject'
  { -- | An array of @ProjectArtifact@ objects.
    UpdateProject -> Maybe [ProjectArtifacts]
secondaryArtifacts :: Prelude.Maybe [ProjectArtifacts],
    -- | Information to be changed about the build output artifacts for the build
    -- project.
    UpdateProject -> Maybe ProjectArtifacts
artifacts :: Prelude.Maybe ProjectArtifacts,
    -- | Information to be changed about the build environment for the build
    -- project.
    UpdateProject -> Maybe ProjectEnvironment
environment :: Prelude.Maybe ProjectEnvironment,
    -- | The maximum number of concurrent builds that are allowed for this
    -- project.
    --
    -- New builds are only started if the current number of builds is less than
    -- or equal to this limit. If the current build count meets this limit, new
    -- builds are throttled and are not run.
    --
    -- To remove this limit, set this value to -1.
    UpdateProject -> Maybe Int
concurrentBuildLimit :: Prelude.Maybe Prelude.Int,
    -- | Set this to true to generate a publicly accessible URL for your
    -- project\'s build badge.
    UpdateProject -> Maybe Bool
badgeEnabled :: Prelude.Maybe Prelude.Bool,
    -- | An array of @ProjectSourceVersion@ objects. If @secondarySourceVersions@
    -- is specified at the build level, then they take over these
    -- @secondarySourceVersions@ (at the project level).
    UpdateProject -> Maybe [ProjectSourceVersion]
secondarySourceVersions :: Prelude.Maybe [ProjectSourceVersion],
    -- | The number of minutes a build is allowed to be queued before it times
    -- out.
    UpdateProject -> Maybe Natural
queuedTimeoutInMinutes :: Prelude.Maybe Prelude.Natural,
    -- | Stores recently used information so that it can be quickly accessed at a
    -- later time.
    UpdateProject -> Maybe ProjectCache
cache :: Prelude.Maybe ProjectCache,
    -- | An array of @ProjectSource@ objects.
    UpdateProject -> Maybe [ProjectSource]
secondarySources :: Prelude.Maybe [ProjectSource],
    -- | A version of the build input to be built for this project. If not
    -- specified, the latest version is used. If specified, it must be one of:
    --
    -- -   For CodeCommit: the commit ID, branch, or Git tag to use.
    --
    -- -   For GitHub: the commit ID, pull request ID, branch name, or tag name
    --     that corresponds to the version of the source code you want to
    --     build. If a pull request ID is specified, it must use the format
    --     @pr\/pull-request-ID@ (for example @pr\/25@). If a branch name is
    --     specified, the branch\'s HEAD commit ID is used. If not specified,
    --     the default branch\'s HEAD commit ID is used.
    --
    -- -   For Bitbucket: the commit ID, branch name, or tag name that
    --     corresponds to the version of the source code you want to build. If
    --     a branch name is specified, the branch\'s HEAD commit ID is used. If
    --     not specified, the default branch\'s HEAD commit ID is used.
    --
    -- -   For Amazon S3: the version ID of the object that represents the
    --     build input ZIP file to use.
    --
    -- If @sourceVersion@ is specified at the build level, then that version
    -- takes precedence over this @sourceVersion@ (at the project level).
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/codebuild/latest/userguide/sample-source-version.html Source Version Sample with CodeBuild>
    -- in the /CodeBuild User Guide/.
    UpdateProject -> Maybe Text
sourceVersion :: Prelude.Maybe Prelude.Text,
    -- | VpcConfig enables CodeBuild to access resources in an Amazon VPC.
    UpdateProject -> Maybe VpcConfig
vpcConfig :: Prelude.Maybe VpcConfig,
    -- | Information to be changed about the build input source code for the
    -- build project.
    UpdateProject -> Maybe ProjectSource
source :: Prelude.Maybe ProjectSource,
    -- | Information about logs for the build project. A project can create logs
    -- in CloudWatch Logs, logs in an S3 bucket, or both.
    UpdateProject -> Maybe LogsConfig
logsConfig :: Prelude.Maybe LogsConfig,
    -- | An array of @ProjectFileSystemLocation@ objects for a CodeBuild build
    -- project. A @ProjectFileSystemLocation@ object specifies the
    -- @identifier@, @location@, @mountOptions@, @mountPoint@, and @type@ of a
    -- file system created using Amazon Elastic File System.
    UpdateProject -> Maybe [ProjectFileSystemLocation]
fileSystemLocations :: Prelude.Maybe [ProjectFileSystemLocation],
    UpdateProject -> Maybe ProjectBuildBatchConfig
buildBatchConfig :: Prelude.Maybe ProjectBuildBatchConfig,
    -- | The Key Management Service customer master key (CMK) to be used for
    -- encrypting the build output artifacts.
    --
    -- You can use a cross-account KMS key to encrypt the build output
    -- artifacts if your service role has permission to that key.
    --
    -- You can specify either the Amazon Resource Name (ARN) of the CMK or, if
    -- available, the CMK\'s alias (using the format @alias\/\<alias-name>@).
    UpdateProject -> Maybe Text
encryptionKey :: Prelude.Maybe Prelude.Text,
    -- | A new or replacement description of the build project.
    UpdateProject -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The replacement ARN of the IAM role that enables CodeBuild to interact
    -- with dependent Amazon Web Services services on behalf of the Amazon Web
    -- Services account.
    UpdateProject -> Maybe Text
serviceRole :: Prelude.Maybe Prelude.Text,
    -- | An updated list of tag key and value pairs associated with this build
    -- project.
    --
    -- These tags are available for use by Amazon Web Services services that
    -- support CodeBuild build project tags.
    UpdateProject -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The replacement value in minutes, from 5 to 480 (8 hours), for CodeBuild
    -- to wait before timing out any related build that did not get marked as
    -- completed.
    UpdateProject -> Maybe Natural
timeoutInMinutes :: Prelude.Maybe Prelude.Natural,
    -- | The name of the build project.
    --
    -- You cannot change a build project\'s name.
    UpdateProject -> Text
name :: Prelude.Text
  }
  deriving (UpdateProject -> UpdateProject -> Bool
(UpdateProject -> UpdateProject -> Bool)
-> (UpdateProject -> UpdateProject -> Bool) -> Eq UpdateProject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateProject -> UpdateProject -> Bool
$c/= :: UpdateProject -> UpdateProject -> Bool
== :: UpdateProject -> UpdateProject -> Bool
$c== :: UpdateProject -> UpdateProject -> Bool
Prelude.Eq, ReadPrec [UpdateProject]
ReadPrec UpdateProject
Int -> ReadS UpdateProject
ReadS [UpdateProject]
(Int -> ReadS UpdateProject)
-> ReadS [UpdateProject]
-> ReadPrec UpdateProject
-> ReadPrec [UpdateProject]
-> Read UpdateProject
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateProject]
$creadListPrec :: ReadPrec [UpdateProject]
readPrec :: ReadPrec UpdateProject
$creadPrec :: ReadPrec UpdateProject
readList :: ReadS [UpdateProject]
$creadList :: ReadS [UpdateProject]
readsPrec :: Int -> ReadS UpdateProject
$creadsPrec :: Int -> ReadS UpdateProject
Prelude.Read, Int -> UpdateProject -> ShowS
[UpdateProject] -> ShowS
UpdateProject -> String
(Int -> UpdateProject -> ShowS)
-> (UpdateProject -> String)
-> ([UpdateProject] -> ShowS)
-> Show UpdateProject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateProject] -> ShowS
$cshowList :: [UpdateProject] -> ShowS
show :: UpdateProject -> String
$cshow :: UpdateProject -> String
showsPrec :: Int -> UpdateProject -> ShowS
$cshowsPrec :: Int -> UpdateProject -> ShowS
Prelude.Show, (forall x. UpdateProject -> Rep UpdateProject x)
-> (forall x. Rep UpdateProject x -> UpdateProject)
-> Generic UpdateProject
forall x. Rep UpdateProject x -> UpdateProject
forall x. UpdateProject -> Rep UpdateProject x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateProject x -> UpdateProject
$cfrom :: forall x. UpdateProject -> Rep UpdateProject x
Prelude.Generic)

-- |
-- Create a value of 'UpdateProject' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'secondaryArtifacts', 'updateProject_secondaryArtifacts' - An array of @ProjectArtifact@ objects.
--
-- 'artifacts', 'updateProject_artifacts' - Information to be changed about the build output artifacts for the build
-- project.
--
-- 'environment', 'updateProject_environment' - Information to be changed about the build environment for the build
-- project.
--
-- 'concurrentBuildLimit', 'updateProject_concurrentBuildLimit' - The maximum number of concurrent builds that are allowed for this
-- project.
--
-- New builds are only started if the current number of builds is less than
-- or equal to this limit. If the current build count meets this limit, new
-- builds are throttled and are not run.
--
-- To remove this limit, set this value to -1.
--
-- 'badgeEnabled', 'updateProject_badgeEnabled' - Set this to true to generate a publicly accessible URL for your
-- project\'s build badge.
--
-- 'secondarySourceVersions', 'updateProject_secondarySourceVersions' - An array of @ProjectSourceVersion@ objects. If @secondarySourceVersions@
-- is specified at the build level, then they take over these
-- @secondarySourceVersions@ (at the project level).
--
-- 'queuedTimeoutInMinutes', 'updateProject_queuedTimeoutInMinutes' - The number of minutes a build is allowed to be queued before it times
-- out.
--
-- 'cache', 'updateProject_cache' - Stores recently used information so that it can be quickly accessed at a
-- later time.
--
-- 'secondarySources', 'updateProject_secondarySources' - An array of @ProjectSource@ objects.
--
-- 'sourceVersion', 'updateProject_sourceVersion' - A version of the build input to be built for this project. If not
-- specified, the latest version is used. If specified, it must be one of:
--
-- -   For CodeCommit: the commit ID, branch, or Git tag to use.
--
-- -   For GitHub: the commit ID, pull request ID, branch name, or tag name
--     that corresponds to the version of the source code you want to
--     build. If a pull request ID is specified, it must use the format
--     @pr\/pull-request-ID@ (for example @pr\/25@). If a branch name is
--     specified, the branch\'s HEAD commit ID is used. If not specified,
--     the default branch\'s HEAD commit ID is used.
--
-- -   For Bitbucket: the commit ID, branch name, or tag name that
--     corresponds to the version of the source code you want to build. If
--     a branch name is specified, the branch\'s HEAD commit ID is used. If
--     not specified, the default branch\'s HEAD commit ID is used.
--
-- -   For Amazon S3: the version ID of the object that represents the
--     build input ZIP file to use.
--
-- If @sourceVersion@ is specified at the build level, then that version
-- takes precedence over this @sourceVersion@ (at the project level).
--
-- For more information, see
-- <https://docs.aws.amazon.com/codebuild/latest/userguide/sample-source-version.html Source Version Sample with CodeBuild>
-- in the /CodeBuild User Guide/.
--
-- 'vpcConfig', 'updateProject_vpcConfig' - VpcConfig enables CodeBuild to access resources in an Amazon VPC.
--
-- 'source', 'updateProject_source' - Information to be changed about the build input source code for the
-- build project.
--
-- 'logsConfig', 'updateProject_logsConfig' - Information about logs for the build project. A project can create logs
-- in CloudWatch Logs, logs in an S3 bucket, or both.
--
-- 'fileSystemLocations', 'updateProject_fileSystemLocations' - An array of @ProjectFileSystemLocation@ objects for a CodeBuild build
-- project. A @ProjectFileSystemLocation@ object specifies the
-- @identifier@, @location@, @mountOptions@, @mountPoint@, and @type@ of a
-- file system created using Amazon Elastic File System.
--
-- 'buildBatchConfig', 'updateProject_buildBatchConfig' - Undocumented member.
--
-- 'encryptionKey', 'updateProject_encryptionKey' - The Key Management Service customer master key (CMK) to be used for
-- encrypting the build output artifacts.
--
-- You can use a cross-account KMS key to encrypt the build output
-- artifacts if your service role has permission to that key.
--
-- You can specify either the Amazon Resource Name (ARN) of the CMK or, if
-- available, the CMK\'s alias (using the format @alias\/\<alias-name>@).
--
-- 'description', 'updateProject_description' - A new or replacement description of the build project.
--
-- 'serviceRole', 'updateProject_serviceRole' - The replacement ARN of the IAM role that enables CodeBuild to interact
-- with dependent Amazon Web Services services on behalf of the Amazon Web
-- Services account.
--
-- 'tags', 'updateProject_tags' - An updated list of tag key and value pairs associated with this build
-- project.
--
-- These tags are available for use by Amazon Web Services services that
-- support CodeBuild build project tags.
--
-- 'timeoutInMinutes', 'updateProject_timeoutInMinutes' - The replacement value in minutes, from 5 to 480 (8 hours), for CodeBuild
-- to wait before timing out any related build that did not get marked as
-- completed.
--
-- 'name', 'updateProject_name' - The name of the build project.
--
-- You cannot change a build project\'s name.
newUpdateProject ::
  -- | 'name'
  Prelude.Text ->
  UpdateProject
newUpdateProject :: Text -> UpdateProject
newUpdateProject Text
pName_ =
  UpdateProject' :: Maybe [ProjectArtifacts]
-> Maybe ProjectArtifacts
-> Maybe ProjectEnvironment
-> Maybe Int
-> Maybe Bool
-> Maybe [ProjectSourceVersion]
-> Maybe Natural
-> Maybe ProjectCache
-> Maybe [ProjectSource]
-> Maybe Text
-> Maybe VpcConfig
-> Maybe ProjectSource
-> Maybe LogsConfig
-> Maybe [ProjectFileSystemLocation]
-> Maybe ProjectBuildBatchConfig
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe [Tag]
-> Maybe Natural
-> Text
-> UpdateProject
UpdateProject'
    { $sel:secondaryArtifacts:UpdateProject' :: Maybe [ProjectArtifacts]
secondaryArtifacts =
        Maybe [ProjectArtifacts]
forall a. Maybe a
Prelude.Nothing,
      $sel:artifacts:UpdateProject' :: Maybe ProjectArtifacts
artifacts = Maybe ProjectArtifacts
forall a. Maybe a
Prelude.Nothing,
      $sel:environment:UpdateProject' :: Maybe ProjectEnvironment
environment = Maybe ProjectEnvironment
forall a. Maybe a
Prelude.Nothing,
      $sel:concurrentBuildLimit:UpdateProject' :: Maybe Int
concurrentBuildLimit = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:badgeEnabled:UpdateProject' :: Maybe Bool
badgeEnabled = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:secondarySourceVersions:UpdateProject' :: Maybe [ProjectSourceVersion]
secondarySourceVersions = Maybe [ProjectSourceVersion]
forall a. Maybe a
Prelude.Nothing,
      $sel:queuedTimeoutInMinutes:UpdateProject' :: Maybe Natural
queuedTimeoutInMinutes = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:cache:UpdateProject' :: Maybe ProjectCache
cache = Maybe ProjectCache
forall a. Maybe a
Prelude.Nothing,
      $sel:secondarySources:UpdateProject' :: Maybe [ProjectSource]
secondarySources = Maybe [ProjectSource]
forall a. Maybe a
Prelude.Nothing,
      $sel:sourceVersion:UpdateProject' :: Maybe Text
sourceVersion = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:vpcConfig:UpdateProject' :: Maybe VpcConfig
vpcConfig = Maybe VpcConfig
forall a. Maybe a
Prelude.Nothing,
      $sel:source:UpdateProject' :: Maybe ProjectSource
source = Maybe ProjectSource
forall a. Maybe a
Prelude.Nothing,
      $sel:logsConfig:UpdateProject' :: Maybe LogsConfig
logsConfig = Maybe LogsConfig
forall a. Maybe a
Prelude.Nothing,
      $sel:fileSystemLocations:UpdateProject' :: Maybe [ProjectFileSystemLocation]
fileSystemLocations = Maybe [ProjectFileSystemLocation]
forall a. Maybe a
Prelude.Nothing,
      $sel:buildBatchConfig:UpdateProject' :: Maybe ProjectBuildBatchConfig
buildBatchConfig = Maybe ProjectBuildBatchConfig
forall a. Maybe a
Prelude.Nothing,
      $sel:encryptionKey:UpdateProject' :: Maybe Text
encryptionKey = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:description:UpdateProject' :: Maybe Text
description = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:serviceRole:UpdateProject' :: Maybe Text
serviceRole = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:tags:UpdateProject' :: Maybe [Tag]
tags = Maybe [Tag]
forall a. Maybe a
Prelude.Nothing,
      $sel:timeoutInMinutes:UpdateProject' :: Maybe Natural
timeoutInMinutes = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:name:UpdateProject' :: Text
name = Text
pName_
    }

-- | An array of @ProjectArtifact@ objects.
updateProject_secondaryArtifacts :: Lens.Lens' UpdateProject (Prelude.Maybe [ProjectArtifacts])
updateProject_secondaryArtifacts :: (Maybe [ProjectArtifacts] -> f (Maybe [ProjectArtifacts]))
-> UpdateProject -> f UpdateProject
updateProject_secondaryArtifacts = (UpdateProject -> Maybe [ProjectArtifacts])
-> (UpdateProject -> Maybe [ProjectArtifacts] -> UpdateProject)
-> Lens
     UpdateProject
     UpdateProject
     (Maybe [ProjectArtifacts])
     (Maybe [ProjectArtifacts])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe [ProjectArtifacts]
secondaryArtifacts :: Maybe [ProjectArtifacts]
$sel:secondaryArtifacts:UpdateProject' :: UpdateProject -> Maybe [ProjectArtifacts]
secondaryArtifacts} -> Maybe [ProjectArtifacts]
secondaryArtifacts) (\s :: UpdateProject
s@UpdateProject' {} Maybe [ProjectArtifacts]
a -> UpdateProject
s {$sel:secondaryArtifacts:UpdateProject' :: Maybe [ProjectArtifacts]
secondaryArtifacts = Maybe [ProjectArtifacts]
a} :: UpdateProject) ((Maybe [ProjectArtifacts] -> f (Maybe [ProjectArtifacts]))
 -> UpdateProject -> f UpdateProject)
-> ((Maybe [ProjectArtifacts] -> f (Maybe [ProjectArtifacts]))
    -> Maybe [ProjectArtifacts] -> f (Maybe [ProjectArtifacts]))
-> (Maybe [ProjectArtifacts] -> f (Maybe [ProjectArtifacts]))
-> UpdateProject
-> f UpdateProject
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ProjectArtifacts]
  [ProjectArtifacts]
  [ProjectArtifacts]
  [ProjectArtifacts]
-> Iso
     (Maybe [ProjectArtifacts])
     (Maybe [ProjectArtifacts])
     (Maybe [ProjectArtifacts])
     (Maybe [ProjectArtifacts])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  [ProjectArtifacts]
  [ProjectArtifacts]
  [ProjectArtifacts]
  [ProjectArtifacts]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Information to be changed about the build output artifacts for the build
-- project.
updateProject_artifacts :: Lens.Lens' UpdateProject (Prelude.Maybe ProjectArtifacts)
updateProject_artifacts :: (Maybe ProjectArtifacts -> f (Maybe ProjectArtifacts))
-> UpdateProject -> f UpdateProject
updateProject_artifacts = (UpdateProject -> Maybe ProjectArtifacts)
-> (UpdateProject -> Maybe ProjectArtifacts -> UpdateProject)
-> Lens
     UpdateProject
     UpdateProject
     (Maybe ProjectArtifacts)
     (Maybe ProjectArtifacts)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe ProjectArtifacts
artifacts :: Maybe ProjectArtifacts
$sel:artifacts:UpdateProject' :: UpdateProject -> Maybe ProjectArtifacts
artifacts} -> Maybe ProjectArtifacts
artifacts) (\s :: UpdateProject
s@UpdateProject' {} Maybe ProjectArtifacts
a -> UpdateProject
s {$sel:artifacts:UpdateProject' :: Maybe ProjectArtifacts
artifacts = Maybe ProjectArtifacts
a} :: UpdateProject)

-- | Information to be changed about the build environment for the build
-- project.
updateProject_environment :: Lens.Lens' UpdateProject (Prelude.Maybe ProjectEnvironment)
updateProject_environment :: (Maybe ProjectEnvironment -> f (Maybe ProjectEnvironment))
-> UpdateProject -> f UpdateProject
updateProject_environment = (UpdateProject -> Maybe ProjectEnvironment)
-> (UpdateProject -> Maybe ProjectEnvironment -> UpdateProject)
-> Lens
     UpdateProject
     UpdateProject
     (Maybe ProjectEnvironment)
     (Maybe ProjectEnvironment)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe ProjectEnvironment
environment :: Maybe ProjectEnvironment
$sel:environment:UpdateProject' :: UpdateProject -> Maybe ProjectEnvironment
environment} -> Maybe ProjectEnvironment
environment) (\s :: UpdateProject
s@UpdateProject' {} Maybe ProjectEnvironment
a -> UpdateProject
s {$sel:environment:UpdateProject' :: Maybe ProjectEnvironment
environment = Maybe ProjectEnvironment
a} :: UpdateProject)

-- | The maximum number of concurrent builds that are allowed for this
-- project.
--
-- New builds are only started if the current number of builds is less than
-- or equal to this limit. If the current build count meets this limit, new
-- builds are throttled and are not run.
--
-- To remove this limit, set this value to -1.
updateProject_concurrentBuildLimit :: Lens.Lens' UpdateProject (Prelude.Maybe Prelude.Int)
updateProject_concurrentBuildLimit :: (Maybe Int -> f (Maybe Int)) -> UpdateProject -> f UpdateProject
updateProject_concurrentBuildLimit = (UpdateProject -> Maybe Int)
-> (UpdateProject -> Maybe Int -> UpdateProject)
-> Lens UpdateProject UpdateProject (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe Int
concurrentBuildLimit :: Maybe Int
$sel:concurrentBuildLimit:UpdateProject' :: UpdateProject -> Maybe Int
concurrentBuildLimit} -> Maybe Int
concurrentBuildLimit) (\s :: UpdateProject
s@UpdateProject' {} Maybe Int
a -> UpdateProject
s {$sel:concurrentBuildLimit:UpdateProject' :: Maybe Int
concurrentBuildLimit = Maybe Int
a} :: UpdateProject)

-- | Set this to true to generate a publicly accessible URL for your
-- project\'s build badge.
updateProject_badgeEnabled :: Lens.Lens' UpdateProject (Prelude.Maybe Prelude.Bool)
updateProject_badgeEnabled :: (Maybe Bool -> f (Maybe Bool)) -> UpdateProject -> f UpdateProject
updateProject_badgeEnabled = (UpdateProject -> Maybe Bool)
-> (UpdateProject -> Maybe Bool -> UpdateProject)
-> Lens UpdateProject UpdateProject (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe Bool
badgeEnabled :: Maybe Bool
$sel:badgeEnabled:UpdateProject' :: UpdateProject -> Maybe Bool
badgeEnabled} -> Maybe Bool
badgeEnabled) (\s :: UpdateProject
s@UpdateProject' {} Maybe Bool
a -> UpdateProject
s {$sel:badgeEnabled:UpdateProject' :: Maybe Bool
badgeEnabled = Maybe Bool
a} :: UpdateProject)

-- | An array of @ProjectSourceVersion@ objects. If @secondarySourceVersions@
-- is specified at the build level, then they take over these
-- @secondarySourceVersions@ (at the project level).
updateProject_secondarySourceVersions :: Lens.Lens' UpdateProject (Prelude.Maybe [ProjectSourceVersion])
updateProject_secondarySourceVersions :: (Maybe [ProjectSourceVersion] -> f (Maybe [ProjectSourceVersion]))
-> UpdateProject -> f UpdateProject
updateProject_secondarySourceVersions = (UpdateProject -> Maybe [ProjectSourceVersion])
-> (UpdateProject -> Maybe [ProjectSourceVersion] -> UpdateProject)
-> Lens
     UpdateProject
     UpdateProject
     (Maybe [ProjectSourceVersion])
     (Maybe [ProjectSourceVersion])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe [ProjectSourceVersion]
secondarySourceVersions :: Maybe [ProjectSourceVersion]
$sel:secondarySourceVersions:UpdateProject' :: UpdateProject -> Maybe [ProjectSourceVersion]
secondarySourceVersions} -> Maybe [ProjectSourceVersion]
secondarySourceVersions) (\s :: UpdateProject
s@UpdateProject' {} Maybe [ProjectSourceVersion]
a -> UpdateProject
s {$sel:secondarySourceVersions:UpdateProject' :: Maybe [ProjectSourceVersion]
secondarySourceVersions = Maybe [ProjectSourceVersion]
a} :: UpdateProject) ((Maybe [ProjectSourceVersion] -> f (Maybe [ProjectSourceVersion]))
 -> UpdateProject -> f UpdateProject)
-> ((Maybe [ProjectSourceVersion]
     -> f (Maybe [ProjectSourceVersion]))
    -> Maybe [ProjectSourceVersion]
    -> f (Maybe [ProjectSourceVersion]))
-> (Maybe [ProjectSourceVersion]
    -> f (Maybe [ProjectSourceVersion]))
-> UpdateProject
-> f UpdateProject
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ProjectSourceVersion]
  [ProjectSourceVersion]
  [ProjectSourceVersion]
  [ProjectSourceVersion]
-> Iso
     (Maybe [ProjectSourceVersion])
     (Maybe [ProjectSourceVersion])
     (Maybe [ProjectSourceVersion])
     (Maybe [ProjectSourceVersion])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  [ProjectSourceVersion]
  [ProjectSourceVersion]
  [ProjectSourceVersion]
  [ProjectSourceVersion]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The number of minutes a build is allowed to be queued before it times
-- out.
updateProject_queuedTimeoutInMinutes :: Lens.Lens' UpdateProject (Prelude.Maybe Prelude.Natural)
updateProject_queuedTimeoutInMinutes :: (Maybe Natural -> f (Maybe Natural))
-> UpdateProject -> f UpdateProject
updateProject_queuedTimeoutInMinutes = (UpdateProject -> Maybe Natural)
-> (UpdateProject -> Maybe Natural -> UpdateProject)
-> Lens UpdateProject UpdateProject (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe Natural
queuedTimeoutInMinutes :: Maybe Natural
$sel:queuedTimeoutInMinutes:UpdateProject' :: UpdateProject -> Maybe Natural
queuedTimeoutInMinutes} -> Maybe Natural
queuedTimeoutInMinutes) (\s :: UpdateProject
s@UpdateProject' {} Maybe Natural
a -> UpdateProject
s {$sel:queuedTimeoutInMinutes:UpdateProject' :: Maybe Natural
queuedTimeoutInMinutes = Maybe Natural
a} :: UpdateProject)

-- | Stores recently used information so that it can be quickly accessed at a
-- later time.
updateProject_cache :: Lens.Lens' UpdateProject (Prelude.Maybe ProjectCache)
updateProject_cache :: (Maybe ProjectCache -> f (Maybe ProjectCache))
-> UpdateProject -> f UpdateProject
updateProject_cache = (UpdateProject -> Maybe ProjectCache)
-> (UpdateProject -> Maybe ProjectCache -> UpdateProject)
-> Lens
     UpdateProject
     UpdateProject
     (Maybe ProjectCache)
     (Maybe ProjectCache)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe ProjectCache
cache :: Maybe ProjectCache
$sel:cache:UpdateProject' :: UpdateProject -> Maybe ProjectCache
cache} -> Maybe ProjectCache
cache) (\s :: UpdateProject
s@UpdateProject' {} Maybe ProjectCache
a -> UpdateProject
s {$sel:cache:UpdateProject' :: Maybe ProjectCache
cache = Maybe ProjectCache
a} :: UpdateProject)

-- | An array of @ProjectSource@ objects.
updateProject_secondarySources :: Lens.Lens' UpdateProject (Prelude.Maybe [ProjectSource])
updateProject_secondarySources :: (Maybe [ProjectSource] -> f (Maybe [ProjectSource]))
-> UpdateProject -> f UpdateProject
updateProject_secondarySources = (UpdateProject -> Maybe [ProjectSource])
-> (UpdateProject -> Maybe [ProjectSource] -> UpdateProject)
-> Lens
     UpdateProject
     UpdateProject
     (Maybe [ProjectSource])
     (Maybe [ProjectSource])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe [ProjectSource]
secondarySources :: Maybe [ProjectSource]
$sel:secondarySources:UpdateProject' :: UpdateProject -> Maybe [ProjectSource]
secondarySources} -> Maybe [ProjectSource]
secondarySources) (\s :: UpdateProject
s@UpdateProject' {} Maybe [ProjectSource]
a -> UpdateProject
s {$sel:secondarySources:UpdateProject' :: Maybe [ProjectSource]
secondarySources = Maybe [ProjectSource]
a} :: UpdateProject) ((Maybe [ProjectSource] -> f (Maybe [ProjectSource]))
 -> UpdateProject -> f UpdateProject)
-> ((Maybe [ProjectSource] -> f (Maybe [ProjectSource]))
    -> Maybe [ProjectSource] -> f (Maybe [ProjectSource]))
-> (Maybe [ProjectSource] -> f (Maybe [ProjectSource]))
-> UpdateProject
-> f UpdateProject
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ProjectSource] [ProjectSource] [ProjectSource] [ProjectSource]
-> Iso
     (Maybe [ProjectSource])
     (Maybe [ProjectSource])
     (Maybe [ProjectSource])
     (Maybe [ProjectSource])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  [ProjectSource] [ProjectSource] [ProjectSource] [ProjectSource]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A version of the build input to be built for this project. If not
-- specified, the latest version is used. If specified, it must be one of:
--
-- -   For CodeCommit: the commit ID, branch, or Git tag to use.
--
-- -   For GitHub: the commit ID, pull request ID, branch name, or tag name
--     that corresponds to the version of the source code you want to
--     build. If a pull request ID is specified, it must use the format
--     @pr\/pull-request-ID@ (for example @pr\/25@). If a branch name is
--     specified, the branch\'s HEAD commit ID is used. If not specified,
--     the default branch\'s HEAD commit ID is used.
--
-- -   For Bitbucket: the commit ID, branch name, or tag name that
--     corresponds to the version of the source code you want to build. If
--     a branch name is specified, the branch\'s HEAD commit ID is used. If
--     not specified, the default branch\'s HEAD commit ID is used.
--
-- -   For Amazon S3: the version ID of the object that represents the
--     build input ZIP file to use.
--
-- If @sourceVersion@ is specified at the build level, then that version
-- takes precedence over this @sourceVersion@ (at the project level).
--
-- For more information, see
-- <https://docs.aws.amazon.com/codebuild/latest/userguide/sample-source-version.html Source Version Sample with CodeBuild>
-- in the /CodeBuild User Guide/.
updateProject_sourceVersion :: Lens.Lens' UpdateProject (Prelude.Maybe Prelude.Text)
updateProject_sourceVersion :: (Maybe Text -> f (Maybe Text)) -> UpdateProject -> f UpdateProject
updateProject_sourceVersion = (UpdateProject -> Maybe Text)
-> (UpdateProject -> Maybe Text -> UpdateProject)
-> Lens UpdateProject UpdateProject (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe Text
sourceVersion :: Maybe Text
$sel:sourceVersion:UpdateProject' :: UpdateProject -> Maybe Text
sourceVersion} -> Maybe Text
sourceVersion) (\s :: UpdateProject
s@UpdateProject' {} Maybe Text
a -> UpdateProject
s {$sel:sourceVersion:UpdateProject' :: Maybe Text
sourceVersion = Maybe Text
a} :: UpdateProject)

-- | VpcConfig enables CodeBuild to access resources in an Amazon VPC.
updateProject_vpcConfig :: Lens.Lens' UpdateProject (Prelude.Maybe VpcConfig)
updateProject_vpcConfig :: (Maybe VpcConfig -> f (Maybe VpcConfig))
-> UpdateProject -> f UpdateProject
updateProject_vpcConfig = (UpdateProject -> Maybe VpcConfig)
-> (UpdateProject -> Maybe VpcConfig -> UpdateProject)
-> Lens
     UpdateProject UpdateProject (Maybe VpcConfig) (Maybe VpcConfig)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe VpcConfig
vpcConfig :: Maybe VpcConfig
$sel:vpcConfig:UpdateProject' :: UpdateProject -> Maybe VpcConfig
vpcConfig} -> Maybe VpcConfig
vpcConfig) (\s :: UpdateProject
s@UpdateProject' {} Maybe VpcConfig
a -> UpdateProject
s {$sel:vpcConfig:UpdateProject' :: Maybe VpcConfig
vpcConfig = Maybe VpcConfig
a} :: UpdateProject)

-- | Information to be changed about the build input source code for the
-- build project.
updateProject_source :: Lens.Lens' UpdateProject (Prelude.Maybe ProjectSource)
updateProject_source :: (Maybe ProjectSource -> f (Maybe ProjectSource))
-> UpdateProject -> f UpdateProject
updateProject_source = (UpdateProject -> Maybe ProjectSource)
-> (UpdateProject -> Maybe ProjectSource -> UpdateProject)
-> Lens
     UpdateProject
     UpdateProject
     (Maybe ProjectSource)
     (Maybe ProjectSource)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe ProjectSource
source :: Maybe ProjectSource
$sel:source:UpdateProject' :: UpdateProject -> Maybe ProjectSource
source} -> Maybe ProjectSource
source) (\s :: UpdateProject
s@UpdateProject' {} Maybe ProjectSource
a -> UpdateProject
s {$sel:source:UpdateProject' :: Maybe ProjectSource
source = Maybe ProjectSource
a} :: UpdateProject)

-- | Information about logs for the build project. A project can create logs
-- in CloudWatch Logs, logs in an S3 bucket, or both.
updateProject_logsConfig :: Lens.Lens' UpdateProject (Prelude.Maybe LogsConfig)
updateProject_logsConfig :: (Maybe LogsConfig -> f (Maybe LogsConfig))
-> UpdateProject -> f UpdateProject
updateProject_logsConfig = (UpdateProject -> Maybe LogsConfig)
-> (UpdateProject -> Maybe LogsConfig -> UpdateProject)
-> Lens
     UpdateProject UpdateProject (Maybe LogsConfig) (Maybe LogsConfig)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe LogsConfig
logsConfig :: Maybe LogsConfig
$sel:logsConfig:UpdateProject' :: UpdateProject -> Maybe LogsConfig
logsConfig} -> Maybe LogsConfig
logsConfig) (\s :: UpdateProject
s@UpdateProject' {} Maybe LogsConfig
a -> UpdateProject
s {$sel:logsConfig:UpdateProject' :: Maybe LogsConfig
logsConfig = Maybe LogsConfig
a} :: UpdateProject)

-- | An array of @ProjectFileSystemLocation@ objects for a CodeBuild build
-- project. A @ProjectFileSystemLocation@ object specifies the
-- @identifier@, @location@, @mountOptions@, @mountPoint@, and @type@ of a
-- file system created using Amazon Elastic File System.
updateProject_fileSystemLocations :: Lens.Lens' UpdateProject (Prelude.Maybe [ProjectFileSystemLocation])
updateProject_fileSystemLocations :: (Maybe [ProjectFileSystemLocation]
 -> f (Maybe [ProjectFileSystemLocation]))
-> UpdateProject -> f UpdateProject
updateProject_fileSystemLocations = (UpdateProject -> Maybe [ProjectFileSystemLocation])
-> (UpdateProject
    -> Maybe [ProjectFileSystemLocation] -> UpdateProject)
-> Lens
     UpdateProject
     UpdateProject
     (Maybe [ProjectFileSystemLocation])
     (Maybe [ProjectFileSystemLocation])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe [ProjectFileSystemLocation]
fileSystemLocations :: Maybe [ProjectFileSystemLocation]
$sel:fileSystemLocations:UpdateProject' :: UpdateProject -> Maybe [ProjectFileSystemLocation]
fileSystemLocations} -> Maybe [ProjectFileSystemLocation]
fileSystemLocations) (\s :: UpdateProject
s@UpdateProject' {} Maybe [ProjectFileSystemLocation]
a -> UpdateProject
s {$sel:fileSystemLocations:UpdateProject' :: Maybe [ProjectFileSystemLocation]
fileSystemLocations = Maybe [ProjectFileSystemLocation]
a} :: UpdateProject) ((Maybe [ProjectFileSystemLocation]
  -> f (Maybe [ProjectFileSystemLocation]))
 -> UpdateProject -> f UpdateProject)
-> ((Maybe [ProjectFileSystemLocation]
     -> f (Maybe [ProjectFileSystemLocation]))
    -> Maybe [ProjectFileSystemLocation]
    -> f (Maybe [ProjectFileSystemLocation]))
-> (Maybe [ProjectFileSystemLocation]
    -> f (Maybe [ProjectFileSystemLocation]))
-> UpdateProject
-> f UpdateProject
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ProjectFileSystemLocation]
  [ProjectFileSystemLocation]
  [ProjectFileSystemLocation]
  [ProjectFileSystemLocation]
-> Iso
     (Maybe [ProjectFileSystemLocation])
     (Maybe [ProjectFileSystemLocation])
     (Maybe [ProjectFileSystemLocation])
     (Maybe [ProjectFileSystemLocation])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  [ProjectFileSystemLocation]
  [ProjectFileSystemLocation]
  [ProjectFileSystemLocation]
  [ProjectFileSystemLocation]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Undocumented member.
updateProject_buildBatchConfig :: Lens.Lens' UpdateProject (Prelude.Maybe ProjectBuildBatchConfig)
updateProject_buildBatchConfig :: (Maybe ProjectBuildBatchConfig
 -> f (Maybe ProjectBuildBatchConfig))
-> UpdateProject -> f UpdateProject
updateProject_buildBatchConfig = (UpdateProject -> Maybe ProjectBuildBatchConfig)
-> (UpdateProject
    -> Maybe ProjectBuildBatchConfig -> UpdateProject)
-> Lens
     UpdateProject
     UpdateProject
     (Maybe ProjectBuildBatchConfig)
     (Maybe ProjectBuildBatchConfig)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe ProjectBuildBatchConfig
buildBatchConfig :: Maybe ProjectBuildBatchConfig
$sel:buildBatchConfig:UpdateProject' :: UpdateProject -> Maybe ProjectBuildBatchConfig
buildBatchConfig} -> Maybe ProjectBuildBatchConfig
buildBatchConfig) (\s :: UpdateProject
s@UpdateProject' {} Maybe ProjectBuildBatchConfig
a -> UpdateProject
s {$sel:buildBatchConfig:UpdateProject' :: Maybe ProjectBuildBatchConfig
buildBatchConfig = Maybe ProjectBuildBatchConfig
a} :: UpdateProject)

-- | The Key Management Service customer master key (CMK) to be used for
-- encrypting the build output artifacts.
--
-- You can use a cross-account KMS key to encrypt the build output
-- artifacts if your service role has permission to that key.
--
-- You can specify either the Amazon Resource Name (ARN) of the CMK or, if
-- available, the CMK\'s alias (using the format @alias\/\<alias-name>@).
updateProject_encryptionKey :: Lens.Lens' UpdateProject (Prelude.Maybe Prelude.Text)
updateProject_encryptionKey :: (Maybe Text -> f (Maybe Text)) -> UpdateProject -> f UpdateProject
updateProject_encryptionKey = (UpdateProject -> Maybe Text)
-> (UpdateProject -> Maybe Text -> UpdateProject)
-> Lens UpdateProject UpdateProject (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe Text
encryptionKey :: Maybe Text
$sel:encryptionKey:UpdateProject' :: UpdateProject -> Maybe Text
encryptionKey} -> Maybe Text
encryptionKey) (\s :: UpdateProject
s@UpdateProject' {} Maybe Text
a -> UpdateProject
s {$sel:encryptionKey:UpdateProject' :: Maybe Text
encryptionKey = Maybe Text
a} :: UpdateProject)

-- | A new or replacement description of the build project.
updateProject_description :: Lens.Lens' UpdateProject (Prelude.Maybe Prelude.Text)
updateProject_description :: (Maybe Text -> f (Maybe Text)) -> UpdateProject -> f UpdateProject
updateProject_description = (UpdateProject -> Maybe Text)
-> (UpdateProject -> Maybe Text -> UpdateProject)
-> Lens UpdateProject UpdateProject (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe Text
description :: Maybe Text
$sel:description:UpdateProject' :: UpdateProject -> Maybe Text
description} -> Maybe Text
description) (\s :: UpdateProject
s@UpdateProject' {} Maybe Text
a -> UpdateProject
s {$sel:description:UpdateProject' :: Maybe Text
description = Maybe Text
a} :: UpdateProject)

-- | The replacement ARN of the IAM role that enables CodeBuild to interact
-- with dependent Amazon Web Services services on behalf of the Amazon Web
-- Services account.
updateProject_serviceRole :: Lens.Lens' UpdateProject (Prelude.Maybe Prelude.Text)
updateProject_serviceRole :: (Maybe Text -> f (Maybe Text)) -> UpdateProject -> f UpdateProject
updateProject_serviceRole = (UpdateProject -> Maybe Text)
-> (UpdateProject -> Maybe Text -> UpdateProject)
-> Lens UpdateProject UpdateProject (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe Text
serviceRole :: Maybe Text
$sel:serviceRole:UpdateProject' :: UpdateProject -> Maybe Text
serviceRole} -> Maybe Text
serviceRole) (\s :: UpdateProject
s@UpdateProject' {} Maybe Text
a -> UpdateProject
s {$sel:serviceRole:UpdateProject' :: Maybe Text
serviceRole = Maybe Text
a} :: UpdateProject)

-- | An updated list of tag key and value pairs associated with this build
-- project.
--
-- These tags are available for use by Amazon Web Services services that
-- support CodeBuild build project tags.
updateProject_tags :: Lens.Lens' UpdateProject (Prelude.Maybe [Tag])
updateProject_tags :: (Maybe [Tag] -> f (Maybe [Tag]))
-> UpdateProject -> f UpdateProject
updateProject_tags = (UpdateProject -> Maybe [Tag])
-> (UpdateProject -> Maybe [Tag] -> UpdateProject)
-> Lens UpdateProject UpdateProject (Maybe [Tag]) (Maybe [Tag])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:UpdateProject' :: UpdateProject -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: UpdateProject
s@UpdateProject' {} Maybe [Tag]
a -> UpdateProject
s {$sel:tags:UpdateProject' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: UpdateProject) ((Maybe [Tag] -> f (Maybe [Tag]))
 -> UpdateProject -> f UpdateProject)
-> ((Maybe [Tag] -> f (Maybe [Tag]))
    -> Maybe [Tag] -> f (Maybe [Tag]))
-> (Maybe [Tag] -> f (Maybe [Tag]))
-> UpdateProject
-> f UpdateProject
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Tag] [Tag] [Tag] [Tag]
-> Iso (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Tag] [Tag] [Tag] [Tag]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The replacement value in minutes, from 5 to 480 (8 hours), for CodeBuild
-- to wait before timing out any related build that did not get marked as
-- completed.
updateProject_timeoutInMinutes :: Lens.Lens' UpdateProject (Prelude.Maybe Prelude.Natural)
updateProject_timeoutInMinutes :: (Maybe Natural -> f (Maybe Natural))
-> UpdateProject -> f UpdateProject
updateProject_timeoutInMinutes = (UpdateProject -> Maybe Natural)
-> (UpdateProject -> Maybe Natural -> UpdateProject)
-> Lens UpdateProject UpdateProject (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Maybe Natural
timeoutInMinutes :: Maybe Natural
$sel:timeoutInMinutes:UpdateProject' :: UpdateProject -> Maybe Natural
timeoutInMinutes} -> Maybe Natural
timeoutInMinutes) (\s :: UpdateProject
s@UpdateProject' {} Maybe Natural
a -> UpdateProject
s {$sel:timeoutInMinutes:UpdateProject' :: Maybe Natural
timeoutInMinutes = Maybe Natural
a} :: UpdateProject)

-- | The name of the build project.
--
-- You cannot change a build project\'s name.
updateProject_name :: Lens.Lens' UpdateProject Prelude.Text
updateProject_name :: (Text -> f Text) -> UpdateProject -> f UpdateProject
updateProject_name = (UpdateProject -> Text)
-> (UpdateProject -> Text -> UpdateProject)
-> Lens UpdateProject UpdateProject Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProject' {Text
name :: Text
$sel:name:UpdateProject' :: UpdateProject -> Text
name} -> Text
name) (\s :: UpdateProject
s@UpdateProject' {} Text
a -> UpdateProject
s {$sel:name:UpdateProject' :: Text
name = Text
a} :: UpdateProject)

instance Core.AWSRequest UpdateProject where
  type
    AWSResponse UpdateProject =
      UpdateProjectResponse
  request :: UpdateProject -> Request UpdateProject
request = Service -> UpdateProject -> Request UpdateProject
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy UpdateProject
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse UpdateProject)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse UpdateProject))
-> Logger
-> Service
-> Proxy UpdateProject
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse UpdateProject)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Project -> Int -> UpdateProjectResponse
UpdateProjectResponse'
            (Maybe Project -> Int -> UpdateProjectResponse)
-> Either String (Maybe Project)
-> Either String (Int -> UpdateProjectResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe Project)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"project")
            Either String (Int -> UpdateProjectResponse)
-> Either String Int -> Either String UpdateProjectResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable UpdateProject

instance Prelude.NFData UpdateProject

instance Core.ToHeaders UpdateProject where
  toHeaders :: UpdateProject -> ResponseHeaders
toHeaders =
    ResponseHeaders -> UpdateProject -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"CodeBuild_20161006.UpdateProject" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON UpdateProject where
  toJSON :: UpdateProject -> Value
toJSON UpdateProject' {Maybe Bool
Maybe Int
Maybe Natural
Maybe [ProjectArtifacts]
Maybe [ProjectFileSystemLocation]
Maybe [ProjectSourceVersion]
Maybe [ProjectSource]
Maybe [Tag]
Maybe Text
Maybe ProjectArtifacts
Maybe ProjectBuildBatchConfig
Maybe ProjectCache
Maybe ProjectEnvironment
Maybe LogsConfig
Maybe ProjectSource
Maybe VpcConfig
Text
name :: Text
timeoutInMinutes :: Maybe Natural
tags :: Maybe [Tag]
serviceRole :: Maybe Text
description :: Maybe Text
encryptionKey :: Maybe Text
buildBatchConfig :: Maybe ProjectBuildBatchConfig
fileSystemLocations :: Maybe [ProjectFileSystemLocation]
logsConfig :: Maybe LogsConfig
source :: Maybe ProjectSource
vpcConfig :: Maybe VpcConfig
sourceVersion :: Maybe Text
secondarySources :: Maybe [ProjectSource]
cache :: Maybe ProjectCache
queuedTimeoutInMinutes :: Maybe Natural
secondarySourceVersions :: Maybe [ProjectSourceVersion]
badgeEnabled :: Maybe Bool
concurrentBuildLimit :: Maybe Int
environment :: Maybe ProjectEnvironment
artifacts :: Maybe ProjectArtifacts
secondaryArtifacts :: Maybe [ProjectArtifacts]
$sel:name:UpdateProject' :: UpdateProject -> Text
$sel:timeoutInMinutes:UpdateProject' :: UpdateProject -> Maybe Natural
$sel:tags:UpdateProject' :: UpdateProject -> Maybe [Tag]
$sel:serviceRole:UpdateProject' :: UpdateProject -> Maybe Text
$sel:description:UpdateProject' :: UpdateProject -> Maybe Text
$sel:encryptionKey:UpdateProject' :: UpdateProject -> Maybe Text
$sel:buildBatchConfig:UpdateProject' :: UpdateProject -> Maybe ProjectBuildBatchConfig
$sel:fileSystemLocations:UpdateProject' :: UpdateProject -> Maybe [ProjectFileSystemLocation]
$sel:logsConfig:UpdateProject' :: UpdateProject -> Maybe LogsConfig
$sel:source:UpdateProject' :: UpdateProject -> Maybe ProjectSource
$sel:vpcConfig:UpdateProject' :: UpdateProject -> Maybe VpcConfig
$sel:sourceVersion:UpdateProject' :: UpdateProject -> Maybe Text
$sel:secondarySources:UpdateProject' :: UpdateProject -> Maybe [ProjectSource]
$sel:cache:UpdateProject' :: UpdateProject -> Maybe ProjectCache
$sel:queuedTimeoutInMinutes:UpdateProject' :: UpdateProject -> Maybe Natural
$sel:secondarySourceVersions:UpdateProject' :: UpdateProject -> Maybe [ProjectSourceVersion]
$sel:badgeEnabled:UpdateProject' :: UpdateProject -> Maybe Bool
$sel:concurrentBuildLimit:UpdateProject' :: UpdateProject -> Maybe Int
$sel:environment:UpdateProject' :: UpdateProject -> Maybe ProjectEnvironment
$sel:artifacts:UpdateProject' :: UpdateProject -> Maybe ProjectArtifacts
$sel:secondaryArtifacts:UpdateProject' :: UpdateProject -> Maybe [ProjectArtifacts]
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"secondaryArtifacts" Text -> [ProjectArtifacts] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([ProjectArtifacts] -> Pair)
-> Maybe [ProjectArtifacts] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [ProjectArtifacts]
secondaryArtifacts,
            (Text
"artifacts" Text -> ProjectArtifacts -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (ProjectArtifacts -> Pair) -> Maybe ProjectArtifacts -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ProjectArtifacts
artifacts,
            (Text
"environment" Text -> ProjectEnvironment -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (ProjectEnvironment -> Pair)
-> Maybe ProjectEnvironment -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ProjectEnvironment
environment,
            (Text
"concurrentBuildLimit" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
concurrentBuildLimit,
            (Text
"badgeEnabled" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
badgeEnabled,
            (Text
"secondarySourceVersions" Text -> [ProjectSourceVersion] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([ProjectSourceVersion] -> Pair)
-> Maybe [ProjectSourceVersion] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [ProjectSourceVersion]
secondarySourceVersions,
            (Text
"queuedTimeoutInMinutes" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
queuedTimeoutInMinutes,
            (Text
"cache" Text -> ProjectCache -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (ProjectCache -> Pair) -> Maybe ProjectCache -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ProjectCache
cache,
            (Text
"secondarySources" Text -> [ProjectSource] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([ProjectSource] -> Pair) -> Maybe [ProjectSource] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [ProjectSource]
secondarySources,
            (Text
"sourceVersion" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
sourceVersion,
            (Text
"vpcConfig" Text -> VpcConfig -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (VpcConfig -> Pair) -> Maybe VpcConfig -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe VpcConfig
vpcConfig,
            (Text
"source" Text -> ProjectSource -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (ProjectSource -> Pair) -> Maybe ProjectSource -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ProjectSource
source,
            (Text
"logsConfig" Text -> LogsConfig -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (LogsConfig -> Pair) -> Maybe LogsConfig -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe LogsConfig
logsConfig,
            (Text
"fileSystemLocations" Text -> [ProjectFileSystemLocation] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([ProjectFileSystemLocation] -> Pair)
-> Maybe [ProjectFileSystemLocation] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [ProjectFileSystemLocation]
fileSystemLocations,
            (Text
"buildBatchConfig" Text -> ProjectBuildBatchConfig -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ProjectBuildBatchConfig -> Pair)
-> Maybe ProjectBuildBatchConfig -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ProjectBuildBatchConfig
buildBatchConfig,
            (Text
"encryptionKey" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
encryptionKey,
            (Text
"description" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
description,
            (Text
"serviceRole" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
serviceRole,
            (Text
"tags" Text -> [Tag] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) ([Tag] -> Pair) -> Maybe [Tag] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tags,
            (Text
"timeoutInMinutes" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
timeoutInMinutes,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"name" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
name)
          ]
      )

instance Core.ToPath UpdateProject where
  toPath :: UpdateProject -> ByteString
toPath = ByteString -> UpdateProject -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Core.ToQuery UpdateProject where
  toQuery :: UpdateProject -> QueryString
toQuery = QueryString -> UpdateProject -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newUpdateProjectResponse' smart constructor.
data UpdateProjectResponse = UpdateProjectResponse'
  { -- | Information about the build project that was changed.
    UpdateProjectResponse -> Maybe Project
project :: Prelude.Maybe Project,
    -- | The response's http status code.
    UpdateProjectResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdateProjectResponse -> UpdateProjectResponse -> Bool
(UpdateProjectResponse -> UpdateProjectResponse -> Bool)
-> (UpdateProjectResponse -> UpdateProjectResponse -> Bool)
-> Eq UpdateProjectResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateProjectResponse -> UpdateProjectResponse -> Bool
$c/= :: UpdateProjectResponse -> UpdateProjectResponse -> Bool
== :: UpdateProjectResponse -> UpdateProjectResponse -> Bool
$c== :: UpdateProjectResponse -> UpdateProjectResponse -> Bool
Prelude.Eq, ReadPrec [UpdateProjectResponse]
ReadPrec UpdateProjectResponse
Int -> ReadS UpdateProjectResponse
ReadS [UpdateProjectResponse]
(Int -> ReadS UpdateProjectResponse)
-> ReadS [UpdateProjectResponse]
-> ReadPrec UpdateProjectResponse
-> ReadPrec [UpdateProjectResponse]
-> Read UpdateProjectResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateProjectResponse]
$creadListPrec :: ReadPrec [UpdateProjectResponse]
readPrec :: ReadPrec UpdateProjectResponse
$creadPrec :: ReadPrec UpdateProjectResponse
readList :: ReadS [UpdateProjectResponse]
$creadList :: ReadS [UpdateProjectResponse]
readsPrec :: Int -> ReadS UpdateProjectResponse
$creadsPrec :: Int -> ReadS UpdateProjectResponse
Prelude.Read, Int -> UpdateProjectResponse -> ShowS
[UpdateProjectResponse] -> ShowS
UpdateProjectResponse -> String
(Int -> UpdateProjectResponse -> ShowS)
-> (UpdateProjectResponse -> String)
-> ([UpdateProjectResponse] -> ShowS)
-> Show UpdateProjectResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateProjectResponse] -> ShowS
$cshowList :: [UpdateProjectResponse] -> ShowS
show :: UpdateProjectResponse -> String
$cshow :: UpdateProjectResponse -> String
showsPrec :: Int -> UpdateProjectResponse -> ShowS
$cshowsPrec :: Int -> UpdateProjectResponse -> ShowS
Prelude.Show, (forall x. UpdateProjectResponse -> Rep UpdateProjectResponse x)
-> (forall x. Rep UpdateProjectResponse x -> UpdateProjectResponse)
-> Generic UpdateProjectResponse
forall x. Rep UpdateProjectResponse x -> UpdateProjectResponse
forall x. UpdateProjectResponse -> Rep UpdateProjectResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateProjectResponse x -> UpdateProjectResponse
$cfrom :: forall x. UpdateProjectResponse -> Rep UpdateProjectResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdateProjectResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'project', 'updateProjectResponse_project' - Information about the build project that was changed.
--
-- 'httpStatus', 'updateProjectResponse_httpStatus' - The response's http status code.
newUpdateProjectResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateProjectResponse
newUpdateProjectResponse :: Int -> UpdateProjectResponse
newUpdateProjectResponse Int
pHttpStatus_ =
  UpdateProjectResponse' :: Maybe Project -> Int -> UpdateProjectResponse
UpdateProjectResponse'
    { $sel:project:UpdateProjectResponse' :: Maybe Project
project = Maybe Project
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateProjectResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the build project that was changed.
updateProjectResponse_project :: Lens.Lens' UpdateProjectResponse (Prelude.Maybe Project)
updateProjectResponse_project :: (Maybe Project -> f (Maybe Project))
-> UpdateProjectResponse -> f UpdateProjectResponse
updateProjectResponse_project = (UpdateProjectResponse -> Maybe Project)
-> (UpdateProjectResponse
    -> Maybe Project -> UpdateProjectResponse)
-> Lens
     UpdateProjectResponse
     UpdateProjectResponse
     (Maybe Project)
     (Maybe Project)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProjectResponse' {Maybe Project
project :: Maybe Project
$sel:project:UpdateProjectResponse' :: UpdateProjectResponse -> Maybe Project
project} -> Maybe Project
project) (\s :: UpdateProjectResponse
s@UpdateProjectResponse' {} Maybe Project
a -> UpdateProjectResponse
s {$sel:project:UpdateProjectResponse' :: Maybe Project
project = Maybe Project
a} :: UpdateProjectResponse)

-- | The response's http status code.
updateProjectResponse_httpStatus :: Lens.Lens' UpdateProjectResponse Prelude.Int
updateProjectResponse_httpStatus :: (Int -> f Int) -> UpdateProjectResponse -> f UpdateProjectResponse
updateProjectResponse_httpStatus = (UpdateProjectResponse -> Int)
-> (UpdateProjectResponse -> Int -> UpdateProjectResponse)
-> Lens UpdateProjectResponse UpdateProjectResponse Int Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateProjectResponse' {Int
httpStatus :: Int
$sel:httpStatus:UpdateProjectResponse' :: UpdateProjectResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: UpdateProjectResponse
s@UpdateProjectResponse' {} Int
a -> UpdateProjectResponse
s {$sel:httpStatus:UpdateProjectResponse' :: Int
httpStatus = Int
a} :: UpdateProjectResponse)

instance Prelude.NFData UpdateProjectResponse