{-# 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.DataPipeline.PutPipelineDefinition
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Adds tasks, schedules, and preconditions to the specified pipeline. You
-- can use @PutPipelineDefinition@ to populate a new pipeline.
--
-- @PutPipelineDefinition@ also validates the configuration as it adds it
-- to the pipeline. Changes to the pipeline are saved unless one of the
-- following three validation errors exists in the pipeline.
--
-- 1.  An object is missing a name or identifier field.
-- 2.  A string or reference field is empty.
-- 3.  The number of objects in the pipeline exceeds the maximum allowed
--     objects.
-- 4.  The pipeline is in a FINISHED state.
--
-- Pipeline object definitions are passed to the @PutPipelineDefinition@
-- action and returned by the GetPipelineDefinition action.
module Amazonka.DataPipeline.PutPipelineDefinition
  ( -- * Creating a Request
    PutPipelineDefinition (..),
    newPutPipelineDefinition,

    -- * Request Lenses
    putPipelineDefinition_parameterObjects,
    putPipelineDefinition_parameterValues,
    putPipelineDefinition_pipelineId,
    putPipelineDefinition_pipelineObjects,

    -- * Destructuring the Response
    PutPipelineDefinitionResponse (..),
    newPutPipelineDefinitionResponse,

    -- * Response Lenses
    putPipelineDefinitionResponse_validationErrors,
    putPipelineDefinitionResponse_validationWarnings,
    putPipelineDefinitionResponse_httpStatus,
    putPipelineDefinitionResponse_errored,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.DataPipeline.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | Contains the parameters for PutPipelineDefinition.
--
-- /See:/ 'newPutPipelineDefinition' smart constructor.
data PutPipelineDefinition = PutPipelineDefinition'
  { -- | The parameter objects used with the pipeline.
    PutPipelineDefinition -> Maybe [ParameterObject]
parameterObjects :: Prelude.Maybe [ParameterObject],
    -- | The parameter values used with the pipeline.
    PutPipelineDefinition -> Maybe [ParameterValue]
parameterValues :: Prelude.Maybe [ParameterValue],
    -- | The ID of the pipeline.
    PutPipelineDefinition -> Text
pipelineId :: Prelude.Text,
    -- | The objects that define the pipeline. These objects overwrite the
    -- existing pipeline definition.
    PutPipelineDefinition -> [PipelineObject]
pipelineObjects :: [PipelineObject]
  }
  deriving (PutPipelineDefinition -> PutPipelineDefinition -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PutPipelineDefinition -> PutPipelineDefinition -> Bool
$c/= :: PutPipelineDefinition -> PutPipelineDefinition -> Bool
== :: PutPipelineDefinition -> PutPipelineDefinition -> Bool
$c== :: PutPipelineDefinition -> PutPipelineDefinition -> Bool
Prelude.Eq, ReadPrec [PutPipelineDefinition]
ReadPrec PutPipelineDefinition
Int -> ReadS PutPipelineDefinition
ReadS [PutPipelineDefinition]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PutPipelineDefinition]
$creadListPrec :: ReadPrec [PutPipelineDefinition]
readPrec :: ReadPrec PutPipelineDefinition
$creadPrec :: ReadPrec PutPipelineDefinition
readList :: ReadS [PutPipelineDefinition]
$creadList :: ReadS [PutPipelineDefinition]
readsPrec :: Int -> ReadS PutPipelineDefinition
$creadsPrec :: Int -> ReadS PutPipelineDefinition
Prelude.Read, Int -> PutPipelineDefinition -> ShowS
[PutPipelineDefinition] -> ShowS
PutPipelineDefinition -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PutPipelineDefinition] -> ShowS
$cshowList :: [PutPipelineDefinition] -> ShowS
show :: PutPipelineDefinition -> String
$cshow :: PutPipelineDefinition -> String
showsPrec :: Int -> PutPipelineDefinition -> ShowS
$cshowsPrec :: Int -> PutPipelineDefinition -> ShowS
Prelude.Show, forall x. Rep PutPipelineDefinition x -> PutPipelineDefinition
forall x. PutPipelineDefinition -> Rep PutPipelineDefinition x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PutPipelineDefinition x -> PutPipelineDefinition
$cfrom :: forall x. PutPipelineDefinition -> Rep PutPipelineDefinition x
Prelude.Generic)

-- |
-- Create a value of 'PutPipelineDefinition' 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:
--
-- 'parameterObjects', 'putPipelineDefinition_parameterObjects' - The parameter objects used with the pipeline.
--
-- 'parameterValues', 'putPipelineDefinition_parameterValues' - The parameter values used with the pipeline.
--
-- 'pipelineId', 'putPipelineDefinition_pipelineId' - The ID of the pipeline.
--
-- 'pipelineObjects', 'putPipelineDefinition_pipelineObjects' - The objects that define the pipeline. These objects overwrite the
-- existing pipeline definition.
newPutPipelineDefinition ::
  -- | 'pipelineId'
  Prelude.Text ->
  PutPipelineDefinition
newPutPipelineDefinition :: Text -> PutPipelineDefinition
newPutPipelineDefinition Text
pPipelineId_ =
  PutPipelineDefinition'
    { $sel:parameterObjects:PutPipelineDefinition' :: Maybe [ParameterObject]
parameterObjects =
        forall a. Maybe a
Prelude.Nothing,
      $sel:parameterValues:PutPipelineDefinition' :: Maybe [ParameterValue]
parameterValues = forall a. Maybe a
Prelude.Nothing,
      $sel:pipelineId:PutPipelineDefinition' :: Text
pipelineId = Text
pPipelineId_,
      $sel:pipelineObjects:PutPipelineDefinition' :: [PipelineObject]
pipelineObjects = forall a. Monoid a => a
Prelude.mempty
    }

-- | The parameter objects used with the pipeline.
putPipelineDefinition_parameterObjects :: Lens.Lens' PutPipelineDefinition (Prelude.Maybe [ParameterObject])
putPipelineDefinition_parameterObjects :: Lens' PutPipelineDefinition (Maybe [ParameterObject])
putPipelineDefinition_parameterObjects = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutPipelineDefinition' {Maybe [ParameterObject]
parameterObjects :: Maybe [ParameterObject]
$sel:parameterObjects:PutPipelineDefinition' :: PutPipelineDefinition -> Maybe [ParameterObject]
parameterObjects} -> Maybe [ParameterObject]
parameterObjects) (\s :: PutPipelineDefinition
s@PutPipelineDefinition' {} Maybe [ParameterObject]
a -> PutPipelineDefinition
s {$sel:parameterObjects:PutPipelineDefinition' :: Maybe [ParameterObject]
parameterObjects = Maybe [ParameterObject]
a} :: PutPipelineDefinition) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The parameter values used with the pipeline.
putPipelineDefinition_parameterValues :: Lens.Lens' PutPipelineDefinition (Prelude.Maybe [ParameterValue])
putPipelineDefinition_parameterValues :: Lens' PutPipelineDefinition (Maybe [ParameterValue])
putPipelineDefinition_parameterValues = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutPipelineDefinition' {Maybe [ParameterValue]
parameterValues :: Maybe [ParameterValue]
$sel:parameterValues:PutPipelineDefinition' :: PutPipelineDefinition -> Maybe [ParameterValue]
parameterValues} -> Maybe [ParameterValue]
parameterValues) (\s :: PutPipelineDefinition
s@PutPipelineDefinition' {} Maybe [ParameterValue]
a -> PutPipelineDefinition
s {$sel:parameterValues:PutPipelineDefinition' :: Maybe [ParameterValue]
parameterValues = Maybe [ParameterValue]
a} :: PutPipelineDefinition) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The ID of the pipeline.
putPipelineDefinition_pipelineId :: Lens.Lens' PutPipelineDefinition Prelude.Text
putPipelineDefinition_pipelineId :: Lens' PutPipelineDefinition Text
putPipelineDefinition_pipelineId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutPipelineDefinition' {Text
pipelineId :: Text
$sel:pipelineId:PutPipelineDefinition' :: PutPipelineDefinition -> Text
pipelineId} -> Text
pipelineId) (\s :: PutPipelineDefinition
s@PutPipelineDefinition' {} Text
a -> PutPipelineDefinition
s {$sel:pipelineId:PutPipelineDefinition' :: Text
pipelineId = Text
a} :: PutPipelineDefinition)

-- | The objects that define the pipeline. These objects overwrite the
-- existing pipeline definition.
putPipelineDefinition_pipelineObjects :: Lens.Lens' PutPipelineDefinition [PipelineObject]
putPipelineDefinition_pipelineObjects :: Lens' PutPipelineDefinition [PipelineObject]
putPipelineDefinition_pipelineObjects = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutPipelineDefinition' {[PipelineObject]
pipelineObjects :: [PipelineObject]
$sel:pipelineObjects:PutPipelineDefinition' :: PutPipelineDefinition -> [PipelineObject]
pipelineObjects} -> [PipelineObject]
pipelineObjects) (\s :: PutPipelineDefinition
s@PutPipelineDefinition' {} [PipelineObject]
a -> PutPipelineDefinition
s {$sel:pipelineObjects:PutPipelineDefinition' :: [PipelineObject]
pipelineObjects = [PipelineObject]
a} :: PutPipelineDefinition) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest PutPipelineDefinition where
  type
    AWSResponse PutPipelineDefinition =
      PutPipelineDefinitionResponse
  request :: (Service -> Service)
-> PutPipelineDefinition -> Request PutPipelineDefinition
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy PutPipelineDefinition
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse PutPipelineDefinition)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe [ValidationError]
-> Maybe [ValidationWarning]
-> Int
-> Bool
-> PutPipelineDefinitionResponse
PutPipelineDefinitionResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"validationErrors"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"validationWarnings"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"errored")
      )

instance Prelude.Hashable PutPipelineDefinition where
  hashWithSalt :: Int -> PutPipelineDefinition -> Int
hashWithSalt Int
_salt PutPipelineDefinition' {[PipelineObject]
Maybe [ParameterObject]
Maybe [ParameterValue]
Text
pipelineObjects :: [PipelineObject]
pipelineId :: Text
parameterValues :: Maybe [ParameterValue]
parameterObjects :: Maybe [ParameterObject]
$sel:pipelineObjects:PutPipelineDefinition' :: PutPipelineDefinition -> [PipelineObject]
$sel:pipelineId:PutPipelineDefinition' :: PutPipelineDefinition -> Text
$sel:parameterValues:PutPipelineDefinition' :: PutPipelineDefinition -> Maybe [ParameterValue]
$sel:parameterObjects:PutPipelineDefinition' :: PutPipelineDefinition -> Maybe [ParameterObject]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ParameterObject]
parameterObjects
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ParameterValue]
parameterValues
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
pipelineId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [PipelineObject]
pipelineObjects

instance Prelude.NFData PutPipelineDefinition where
  rnf :: PutPipelineDefinition -> ()
rnf PutPipelineDefinition' {[PipelineObject]
Maybe [ParameterObject]
Maybe [ParameterValue]
Text
pipelineObjects :: [PipelineObject]
pipelineId :: Text
parameterValues :: Maybe [ParameterValue]
parameterObjects :: Maybe [ParameterObject]
$sel:pipelineObjects:PutPipelineDefinition' :: PutPipelineDefinition -> [PipelineObject]
$sel:pipelineId:PutPipelineDefinition' :: PutPipelineDefinition -> Text
$sel:parameterValues:PutPipelineDefinition' :: PutPipelineDefinition -> Maybe [ParameterValue]
$sel:parameterObjects:PutPipelineDefinition' :: PutPipelineDefinition -> Maybe [ParameterObject]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ParameterObject]
parameterObjects
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ParameterValue]
parameterValues
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
pipelineId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [PipelineObject]
pipelineObjects

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

instance Data.ToJSON PutPipelineDefinition where
  toJSON :: PutPipelineDefinition -> Value
toJSON PutPipelineDefinition' {[PipelineObject]
Maybe [ParameterObject]
Maybe [ParameterValue]
Text
pipelineObjects :: [PipelineObject]
pipelineId :: Text
parameterValues :: Maybe [ParameterValue]
parameterObjects :: Maybe [ParameterObject]
$sel:pipelineObjects:PutPipelineDefinition' :: PutPipelineDefinition -> [PipelineObject]
$sel:pipelineId:PutPipelineDefinition' :: PutPipelineDefinition -> Text
$sel:parameterValues:PutPipelineDefinition' :: PutPipelineDefinition -> Maybe [ParameterValue]
$sel:parameterObjects:PutPipelineDefinition' :: PutPipelineDefinition -> Maybe [ParameterObject]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"parameterObjects" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [ParameterObject]
parameterObjects,
            (Key
"parameterValues" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [ParameterValue]
parameterValues,
            forall a. a -> Maybe a
Prelude.Just (Key
"pipelineId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
pipelineId),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"pipelineObjects" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [PipelineObject]
pipelineObjects)
          ]
      )

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

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

-- | Contains the output of PutPipelineDefinition.
--
-- /See:/ 'newPutPipelineDefinitionResponse' smart constructor.
data PutPipelineDefinitionResponse = PutPipelineDefinitionResponse'
  { -- | The validation errors that are associated with the objects defined in
    -- @pipelineObjects@.
    PutPipelineDefinitionResponse -> Maybe [ValidationError]
validationErrors :: Prelude.Maybe [ValidationError],
    -- | The validation warnings that are associated with the objects defined in
    -- @pipelineObjects@.
    PutPipelineDefinitionResponse -> Maybe [ValidationWarning]
validationWarnings :: Prelude.Maybe [ValidationWarning],
    -- | The response's http status code.
    PutPipelineDefinitionResponse -> Int
httpStatus :: Prelude.Int,
    -- | Indicates whether there were validation errors, and the pipeline
    -- definition is stored but cannot be activated until you correct the
    -- pipeline and call @PutPipelineDefinition@ to commit the corrected
    -- pipeline.
    PutPipelineDefinitionResponse -> Bool
errored :: Prelude.Bool
  }
  deriving (PutPipelineDefinitionResponse
-> PutPipelineDefinitionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PutPipelineDefinitionResponse
-> PutPipelineDefinitionResponse -> Bool
$c/= :: PutPipelineDefinitionResponse
-> PutPipelineDefinitionResponse -> Bool
== :: PutPipelineDefinitionResponse
-> PutPipelineDefinitionResponse -> Bool
$c== :: PutPipelineDefinitionResponse
-> PutPipelineDefinitionResponse -> Bool
Prelude.Eq, ReadPrec [PutPipelineDefinitionResponse]
ReadPrec PutPipelineDefinitionResponse
Int -> ReadS PutPipelineDefinitionResponse
ReadS [PutPipelineDefinitionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PutPipelineDefinitionResponse]
$creadListPrec :: ReadPrec [PutPipelineDefinitionResponse]
readPrec :: ReadPrec PutPipelineDefinitionResponse
$creadPrec :: ReadPrec PutPipelineDefinitionResponse
readList :: ReadS [PutPipelineDefinitionResponse]
$creadList :: ReadS [PutPipelineDefinitionResponse]
readsPrec :: Int -> ReadS PutPipelineDefinitionResponse
$creadsPrec :: Int -> ReadS PutPipelineDefinitionResponse
Prelude.Read, Int -> PutPipelineDefinitionResponse -> ShowS
[PutPipelineDefinitionResponse] -> ShowS
PutPipelineDefinitionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PutPipelineDefinitionResponse] -> ShowS
$cshowList :: [PutPipelineDefinitionResponse] -> ShowS
show :: PutPipelineDefinitionResponse -> String
$cshow :: PutPipelineDefinitionResponse -> String
showsPrec :: Int -> PutPipelineDefinitionResponse -> ShowS
$cshowsPrec :: Int -> PutPipelineDefinitionResponse -> ShowS
Prelude.Show, forall x.
Rep PutPipelineDefinitionResponse x
-> PutPipelineDefinitionResponse
forall x.
PutPipelineDefinitionResponse
-> Rep PutPipelineDefinitionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep PutPipelineDefinitionResponse x
-> PutPipelineDefinitionResponse
$cfrom :: forall x.
PutPipelineDefinitionResponse
-> Rep PutPipelineDefinitionResponse x
Prelude.Generic)

-- |
-- Create a value of 'PutPipelineDefinitionResponse' 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:
--
-- 'validationErrors', 'putPipelineDefinitionResponse_validationErrors' - The validation errors that are associated with the objects defined in
-- @pipelineObjects@.
--
-- 'validationWarnings', 'putPipelineDefinitionResponse_validationWarnings' - The validation warnings that are associated with the objects defined in
-- @pipelineObjects@.
--
-- 'httpStatus', 'putPipelineDefinitionResponse_httpStatus' - The response's http status code.
--
-- 'errored', 'putPipelineDefinitionResponse_errored' - Indicates whether there were validation errors, and the pipeline
-- definition is stored but cannot be activated until you correct the
-- pipeline and call @PutPipelineDefinition@ to commit the corrected
-- pipeline.
newPutPipelineDefinitionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'errored'
  Prelude.Bool ->
  PutPipelineDefinitionResponse
newPutPipelineDefinitionResponse :: Int -> Bool -> PutPipelineDefinitionResponse
newPutPipelineDefinitionResponse
  Int
pHttpStatus_
  Bool
pErrored_ =
    PutPipelineDefinitionResponse'
      { $sel:validationErrors:PutPipelineDefinitionResponse' :: Maybe [ValidationError]
validationErrors =
          forall a. Maybe a
Prelude.Nothing,
        $sel:validationWarnings:PutPipelineDefinitionResponse' :: Maybe [ValidationWarning]
validationWarnings = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:PutPipelineDefinitionResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:errored:PutPipelineDefinitionResponse' :: Bool
errored = Bool
pErrored_
      }

-- | The validation errors that are associated with the objects defined in
-- @pipelineObjects@.
putPipelineDefinitionResponse_validationErrors :: Lens.Lens' PutPipelineDefinitionResponse (Prelude.Maybe [ValidationError])
putPipelineDefinitionResponse_validationErrors :: Lens' PutPipelineDefinitionResponse (Maybe [ValidationError])
putPipelineDefinitionResponse_validationErrors = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutPipelineDefinitionResponse' {Maybe [ValidationError]
validationErrors :: Maybe [ValidationError]
$sel:validationErrors:PutPipelineDefinitionResponse' :: PutPipelineDefinitionResponse -> Maybe [ValidationError]
validationErrors} -> Maybe [ValidationError]
validationErrors) (\s :: PutPipelineDefinitionResponse
s@PutPipelineDefinitionResponse' {} Maybe [ValidationError]
a -> PutPipelineDefinitionResponse
s {$sel:validationErrors:PutPipelineDefinitionResponse' :: Maybe [ValidationError]
validationErrors = Maybe [ValidationError]
a} :: PutPipelineDefinitionResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The validation warnings that are associated with the objects defined in
-- @pipelineObjects@.
putPipelineDefinitionResponse_validationWarnings :: Lens.Lens' PutPipelineDefinitionResponse (Prelude.Maybe [ValidationWarning])
putPipelineDefinitionResponse_validationWarnings :: Lens' PutPipelineDefinitionResponse (Maybe [ValidationWarning])
putPipelineDefinitionResponse_validationWarnings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutPipelineDefinitionResponse' {Maybe [ValidationWarning]
validationWarnings :: Maybe [ValidationWarning]
$sel:validationWarnings:PutPipelineDefinitionResponse' :: PutPipelineDefinitionResponse -> Maybe [ValidationWarning]
validationWarnings} -> Maybe [ValidationWarning]
validationWarnings) (\s :: PutPipelineDefinitionResponse
s@PutPipelineDefinitionResponse' {} Maybe [ValidationWarning]
a -> PutPipelineDefinitionResponse
s {$sel:validationWarnings:PutPipelineDefinitionResponse' :: Maybe [ValidationWarning]
validationWarnings = Maybe [ValidationWarning]
a} :: PutPipelineDefinitionResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

-- | Indicates whether there were validation errors, and the pipeline
-- definition is stored but cannot be activated until you correct the
-- pipeline and call @PutPipelineDefinition@ to commit the corrected
-- pipeline.
putPipelineDefinitionResponse_errored :: Lens.Lens' PutPipelineDefinitionResponse Prelude.Bool
putPipelineDefinitionResponse_errored :: Lens' PutPipelineDefinitionResponse Bool
putPipelineDefinitionResponse_errored = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutPipelineDefinitionResponse' {Bool
errored :: Bool
$sel:errored:PutPipelineDefinitionResponse' :: PutPipelineDefinitionResponse -> Bool
errored} -> Bool
errored) (\s :: PutPipelineDefinitionResponse
s@PutPipelineDefinitionResponse' {} Bool
a -> PutPipelineDefinitionResponse
s {$sel:errored:PutPipelineDefinitionResponse' :: Bool
errored = Bool
a} :: PutPipelineDefinitionResponse)

instance Prelude.NFData PutPipelineDefinitionResponse where
  rnf :: PutPipelineDefinitionResponse -> ()
rnf PutPipelineDefinitionResponse' {Bool
Int
Maybe [ValidationError]
Maybe [ValidationWarning]
errored :: Bool
httpStatus :: Int
validationWarnings :: Maybe [ValidationWarning]
validationErrors :: Maybe [ValidationError]
$sel:errored:PutPipelineDefinitionResponse' :: PutPipelineDefinitionResponse -> Bool
$sel:httpStatus:PutPipelineDefinitionResponse' :: PutPipelineDefinitionResponse -> Int
$sel:validationWarnings:PutPipelineDefinitionResponse' :: PutPipelineDefinitionResponse -> Maybe [ValidationWarning]
$sel:validationErrors:PutPipelineDefinitionResponse' :: PutPipelineDefinitionResponse -> Maybe [ValidationError]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ValidationError]
validationErrors
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ValidationWarning]
validationWarnings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Bool
errored