{-# 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.ValidatePipelineDefinition
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Validates the specified pipeline definition to ensure that it is well
-- formed and can be run without error.
module Amazonka.DataPipeline.ValidatePipelineDefinition
  ( -- * Creating a Request
    ValidatePipelineDefinition (..),
    newValidatePipelineDefinition,

    -- * Request Lenses
    validatePipelineDefinition_parameterObjects,
    validatePipelineDefinition_parameterValues,
    validatePipelineDefinition_pipelineId,
    validatePipelineDefinition_pipelineObjects,

    -- * Destructuring the Response
    ValidatePipelineDefinitionResponse (..),
    newValidatePipelineDefinitionResponse,

    -- * Response Lenses
    validatePipelineDefinitionResponse_validationErrors,
    validatePipelineDefinitionResponse_validationWarnings,
    validatePipelineDefinitionResponse_httpStatus,
    validatePipelineDefinitionResponse_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 ValidatePipelineDefinition.
--
-- /See:/ 'newValidatePipelineDefinition' smart constructor.
data ValidatePipelineDefinition = ValidatePipelineDefinition'
  { -- | The parameter objects used with the pipeline.
    ValidatePipelineDefinition -> Maybe [ParameterObject]
parameterObjects :: Prelude.Maybe [ParameterObject],
    -- | The parameter values used with the pipeline.
    ValidatePipelineDefinition -> Maybe [ParameterValue]
parameterValues :: Prelude.Maybe [ParameterValue],
    -- | The ID of the pipeline.
    ValidatePipelineDefinition -> Text
pipelineId :: Prelude.Text,
    -- | The objects that define the pipeline changes to validate against the
    -- pipeline.
    ValidatePipelineDefinition -> [PipelineObject]
pipelineObjects :: [PipelineObject]
  }
  deriving (ValidatePipelineDefinition -> ValidatePipelineDefinition -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ValidatePipelineDefinition -> ValidatePipelineDefinition -> Bool
$c/= :: ValidatePipelineDefinition -> ValidatePipelineDefinition -> Bool
== :: ValidatePipelineDefinition -> ValidatePipelineDefinition -> Bool
$c== :: ValidatePipelineDefinition -> ValidatePipelineDefinition -> Bool
Prelude.Eq, ReadPrec [ValidatePipelineDefinition]
ReadPrec ValidatePipelineDefinition
Int -> ReadS ValidatePipelineDefinition
ReadS [ValidatePipelineDefinition]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ValidatePipelineDefinition]
$creadListPrec :: ReadPrec [ValidatePipelineDefinition]
readPrec :: ReadPrec ValidatePipelineDefinition
$creadPrec :: ReadPrec ValidatePipelineDefinition
readList :: ReadS [ValidatePipelineDefinition]
$creadList :: ReadS [ValidatePipelineDefinition]
readsPrec :: Int -> ReadS ValidatePipelineDefinition
$creadsPrec :: Int -> ReadS ValidatePipelineDefinition
Prelude.Read, Int -> ValidatePipelineDefinition -> ShowS
[ValidatePipelineDefinition] -> ShowS
ValidatePipelineDefinition -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ValidatePipelineDefinition] -> ShowS
$cshowList :: [ValidatePipelineDefinition] -> ShowS
show :: ValidatePipelineDefinition -> String
$cshow :: ValidatePipelineDefinition -> String
showsPrec :: Int -> ValidatePipelineDefinition -> ShowS
$cshowsPrec :: Int -> ValidatePipelineDefinition -> ShowS
Prelude.Show, forall x.
Rep ValidatePipelineDefinition x -> ValidatePipelineDefinition
forall x.
ValidatePipelineDefinition -> Rep ValidatePipelineDefinition x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ValidatePipelineDefinition x -> ValidatePipelineDefinition
$cfrom :: forall x.
ValidatePipelineDefinition -> Rep ValidatePipelineDefinition x
Prelude.Generic)

-- |
-- Create a value of 'ValidatePipelineDefinition' 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', 'validatePipelineDefinition_parameterObjects' - The parameter objects used with the pipeline.
--
-- 'parameterValues', 'validatePipelineDefinition_parameterValues' - The parameter values used with the pipeline.
--
-- 'pipelineId', 'validatePipelineDefinition_pipelineId' - The ID of the pipeline.
--
-- 'pipelineObjects', 'validatePipelineDefinition_pipelineObjects' - The objects that define the pipeline changes to validate against the
-- pipeline.
newValidatePipelineDefinition ::
  -- | 'pipelineId'
  Prelude.Text ->
  ValidatePipelineDefinition
newValidatePipelineDefinition :: Text -> ValidatePipelineDefinition
newValidatePipelineDefinition Text
pPipelineId_ =
  ValidatePipelineDefinition'
    { $sel:parameterObjects:ValidatePipelineDefinition' :: Maybe [ParameterObject]
parameterObjects =
        forall a. Maybe a
Prelude.Nothing,
      $sel:parameterValues:ValidatePipelineDefinition' :: Maybe [ParameterValue]
parameterValues = forall a. Maybe a
Prelude.Nothing,
      $sel:pipelineId:ValidatePipelineDefinition' :: Text
pipelineId = Text
pPipelineId_,
      $sel:pipelineObjects:ValidatePipelineDefinition' :: [PipelineObject]
pipelineObjects = forall a. Monoid a => a
Prelude.mempty
    }

-- | The parameter objects used with the pipeline.
validatePipelineDefinition_parameterObjects :: Lens.Lens' ValidatePipelineDefinition (Prelude.Maybe [ParameterObject])
validatePipelineDefinition_parameterObjects :: Lens' ValidatePipelineDefinition (Maybe [ParameterObject])
validatePipelineDefinition_parameterObjects = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ValidatePipelineDefinition' {Maybe [ParameterObject]
parameterObjects :: Maybe [ParameterObject]
$sel:parameterObjects:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> Maybe [ParameterObject]
parameterObjects} -> Maybe [ParameterObject]
parameterObjects) (\s :: ValidatePipelineDefinition
s@ValidatePipelineDefinition' {} Maybe [ParameterObject]
a -> ValidatePipelineDefinition
s {$sel:parameterObjects:ValidatePipelineDefinition' :: Maybe [ParameterObject]
parameterObjects = Maybe [ParameterObject]
a} :: ValidatePipelineDefinition) 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.
validatePipelineDefinition_parameterValues :: Lens.Lens' ValidatePipelineDefinition (Prelude.Maybe [ParameterValue])
validatePipelineDefinition_parameterValues :: Lens' ValidatePipelineDefinition (Maybe [ParameterValue])
validatePipelineDefinition_parameterValues = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ValidatePipelineDefinition' {Maybe [ParameterValue]
parameterValues :: Maybe [ParameterValue]
$sel:parameterValues:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> Maybe [ParameterValue]
parameterValues} -> Maybe [ParameterValue]
parameterValues) (\s :: ValidatePipelineDefinition
s@ValidatePipelineDefinition' {} Maybe [ParameterValue]
a -> ValidatePipelineDefinition
s {$sel:parameterValues:ValidatePipelineDefinition' :: Maybe [ParameterValue]
parameterValues = Maybe [ParameterValue]
a} :: ValidatePipelineDefinition) 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.
validatePipelineDefinition_pipelineId :: Lens.Lens' ValidatePipelineDefinition Prelude.Text
validatePipelineDefinition_pipelineId :: Lens' ValidatePipelineDefinition Text
validatePipelineDefinition_pipelineId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ValidatePipelineDefinition' {Text
pipelineId :: Text
$sel:pipelineId:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> Text
pipelineId} -> Text
pipelineId) (\s :: ValidatePipelineDefinition
s@ValidatePipelineDefinition' {} Text
a -> ValidatePipelineDefinition
s {$sel:pipelineId:ValidatePipelineDefinition' :: Text
pipelineId = Text
a} :: ValidatePipelineDefinition)

-- | The objects that define the pipeline changes to validate against the
-- pipeline.
validatePipelineDefinition_pipelineObjects :: Lens.Lens' ValidatePipelineDefinition [PipelineObject]
validatePipelineDefinition_pipelineObjects :: Lens' ValidatePipelineDefinition [PipelineObject]
validatePipelineDefinition_pipelineObjects = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ValidatePipelineDefinition' {[PipelineObject]
pipelineObjects :: [PipelineObject]
$sel:pipelineObjects:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> [PipelineObject]
pipelineObjects} -> [PipelineObject]
pipelineObjects) (\s :: ValidatePipelineDefinition
s@ValidatePipelineDefinition' {} [PipelineObject]
a -> ValidatePipelineDefinition
s {$sel:pipelineObjects:ValidatePipelineDefinition' :: [PipelineObject]
pipelineObjects = [PipelineObject]
a} :: ValidatePipelineDefinition) 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 ValidatePipelineDefinition where
  type
    AWSResponse ValidatePipelineDefinition =
      ValidatePipelineDefinitionResponse
  request :: (Service -> Service)
-> ValidatePipelineDefinition -> Request ValidatePipelineDefinition
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 ValidatePipelineDefinition
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ValidatePipelineDefinition)))
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
-> ValidatePipelineDefinitionResponse
ValidatePipelineDefinitionResponse'
            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 ValidatePipelineDefinition where
  hashWithSalt :: Int -> ValidatePipelineDefinition -> Int
hashWithSalt Int
_salt ValidatePipelineDefinition' {[PipelineObject]
Maybe [ParameterObject]
Maybe [ParameterValue]
Text
pipelineObjects :: [PipelineObject]
pipelineId :: Text
parameterValues :: Maybe [ParameterValue]
parameterObjects :: Maybe [ParameterObject]
$sel:pipelineObjects:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> [PipelineObject]
$sel:pipelineId:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> Text
$sel:parameterValues:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> Maybe [ParameterValue]
$sel:parameterObjects:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> 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 ValidatePipelineDefinition where
  rnf :: ValidatePipelineDefinition -> ()
rnf ValidatePipelineDefinition' {[PipelineObject]
Maybe [ParameterObject]
Maybe [ParameterValue]
Text
pipelineObjects :: [PipelineObject]
pipelineId :: Text
parameterValues :: Maybe [ParameterValue]
parameterObjects :: Maybe [ParameterObject]
$sel:pipelineObjects:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> [PipelineObject]
$sel:pipelineId:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> Text
$sel:parameterValues:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> Maybe [ParameterValue]
$sel:parameterObjects:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> 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 ValidatePipelineDefinition where
  toHeaders :: ValidatePipelineDefinition -> 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.ValidatePipelineDefinition" ::
                          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 ValidatePipelineDefinition where
  toJSON :: ValidatePipelineDefinition -> Value
toJSON ValidatePipelineDefinition' {[PipelineObject]
Maybe [ParameterObject]
Maybe [ParameterValue]
Text
pipelineObjects :: [PipelineObject]
pipelineId :: Text
parameterValues :: Maybe [ParameterValue]
parameterObjects :: Maybe [ParameterObject]
$sel:pipelineObjects:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> [PipelineObject]
$sel:pipelineId:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> Text
$sel:parameterValues:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> Maybe [ParameterValue]
$sel:parameterObjects:ValidatePipelineDefinition' :: ValidatePipelineDefinition -> 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 ValidatePipelineDefinition where
  toPath :: ValidatePipelineDefinition -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

-- | Contains the output of ValidatePipelineDefinition.
--
-- /See:/ 'newValidatePipelineDefinitionResponse' smart constructor.
data ValidatePipelineDefinitionResponse = ValidatePipelineDefinitionResponse'
  { -- | Any validation errors that were found.
    ValidatePipelineDefinitionResponse -> Maybe [ValidationError]
validationErrors :: Prelude.Maybe [ValidationError],
    -- | Any validation warnings that were found.
    ValidatePipelineDefinitionResponse -> Maybe [ValidationWarning]
validationWarnings :: Prelude.Maybe [ValidationWarning],
    -- | The response's http status code.
    ValidatePipelineDefinitionResponse -> Int
httpStatus :: Prelude.Int,
    -- | Indicates whether there were validation errors.
    ValidatePipelineDefinitionResponse -> Bool
errored :: Prelude.Bool
  }
  deriving (ValidatePipelineDefinitionResponse
-> ValidatePipelineDefinitionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ValidatePipelineDefinitionResponse
-> ValidatePipelineDefinitionResponse -> Bool
$c/= :: ValidatePipelineDefinitionResponse
-> ValidatePipelineDefinitionResponse -> Bool
== :: ValidatePipelineDefinitionResponse
-> ValidatePipelineDefinitionResponse -> Bool
$c== :: ValidatePipelineDefinitionResponse
-> ValidatePipelineDefinitionResponse -> Bool
Prelude.Eq, ReadPrec [ValidatePipelineDefinitionResponse]
ReadPrec ValidatePipelineDefinitionResponse
Int -> ReadS ValidatePipelineDefinitionResponse
ReadS [ValidatePipelineDefinitionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ValidatePipelineDefinitionResponse]
$creadListPrec :: ReadPrec [ValidatePipelineDefinitionResponse]
readPrec :: ReadPrec ValidatePipelineDefinitionResponse
$creadPrec :: ReadPrec ValidatePipelineDefinitionResponse
readList :: ReadS [ValidatePipelineDefinitionResponse]
$creadList :: ReadS [ValidatePipelineDefinitionResponse]
readsPrec :: Int -> ReadS ValidatePipelineDefinitionResponse
$creadsPrec :: Int -> ReadS ValidatePipelineDefinitionResponse
Prelude.Read, Int -> ValidatePipelineDefinitionResponse -> ShowS
[ValidatePipelineDefinitionResponse] -> ShowS
ValidatePipelineDefinitionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ValidatePipelineDefinitionResponse] -> ShowS
$cshowList :: [ValidatePipelineDefinitionResponse] -> ShowS
show :: ValidatePipelineDefinitionResponse -> String
$cshow :: ValidatePipelineDefinitionResponse -> String
showsPrec :: Int -> ValidatePipelineDefinitionResponse -> ShowS
$cshowsPrec :: Int -> ValidatePipelineDefinitionResponse -> ShowS
Prelude.Show, forall x.
Rep ValidatePipelineDefinitionResponse x
-> ValidatePipelineDefinitionResponse
forall x.
ValidatePipelineDefinitionResponse
-> Rep ValidatePipelineDefinitionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ValidatePipelineDefinitionResponse x
-> ValidatePipelineDefinitionResponse
$cfrom :: forall x.
ValidatePipelineDefinitionResponse
-> Rep ValidatePipelineDefinitionResponse x
Prelude.Generic)

-- |
-- Create a value of 'ValidatePipelineDefinitionResponse' 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', 'validatePipelineDefinitionResponse_validationErrors' - Any validation errors that were found.
--
-- 'validationWarnings', 'validatePipelineDefinitionResponse_validationWarnings' - Any validation warnings that were found.
--
-- 'httpStatus', 'validatePipelineDefinitionResponse_httpStatus' - The response's http status code.
--
-- 'errored', 'validatePipelineDefinitionResponse_errored' - Indicates whether there were validation errors.
newValidatePipelineDefinitionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'errored'
  Prelude.Bool ->
  ValidatePipelineDefinitionResponse
newValidatePipelineDefinitionResponse :: Int -> Bool -> ValidatePipelineDefinitionResponse
newValidatePipelineDefinitionResponse
  Int
pHttpStatus_
  Bool
pErrored_ =
    ValidatePipelineDefinitionResponse'
      { $sel:validationErrors:ValidatePipelineDefinitionResponse' :: Maybe [ValidationError]
validationErrors =
          forall a. Maybe a
Prelude.Nothing,
        $sel:validationWarnings:ValidatePipelineDefinitionResponse' :: Maybe [ValidationWarning]
validationWarnings = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:ValidatePipelineDefinitionResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:errored:ValidatePipelineDefinitionResponse' :: Bool
errored = Bool
pErrored_
      }

-- | Any validation errors that were found.
validatePipelineDefinitionResponse_validationErrors :: Lens.Lens' ValidatePipelineDefinitionResponse (Prelude.Maybe [ValidationError])
validatePipelineDefinitionResponse_validationErrors :: Lens' ValidatePipelineDefinitionResponse (Maybe [ValidationError])
validatePipelineDefinitionResponse_validationErrors = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ValidatePipelineDefinitionResponse' {Maybe [ValidationError]
validationErrors :: Maybe [ValidationError]
$sel:validationErrors:ValidatePipelineDefinitionResponse' :: ValidatePipelineDefinitionResponse -> Maybe [ValidationError]
validationErrors} -> Maybe [ValidationError]
validationErrors) (\s :: ValidatePipelineDefinitionResponse
s@ValidatePipelineDefinitionResponse' {} Maybe [ValidationError]
a -> ValidatePipelineDefinitionResponse
s {$sel:validationErrors:ValidatePipelineDefinitionResponse' :: Maybe [ValidationError]
validationErrors = Maybe [ValidationError]
a} :: ValidatePipelineDefinitionResponse) 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

-- | Any validation warnings that were found.
validatePipelineDefinitionResponse_validationWarnings :: Lens.Lens' ValidatePipelineDefinitionResponse (Prelude.Maybe [ValidationWarning])
validatePipelineDefinitionResponse_validationWarnings :: Lens'
  ValidatePipelineDefinitionResponse (Maybe [ValidationWarning])
validatePipelineDefinitionResponse_validationWarnings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ValidatePipelineDefinitionResponse' {Maybe [ValidationWarning]
validationWarnings :: Maybe [ValidationWarning]
$sel:validationWarnings:ValidatePipelineDefinitionResponse' :: ValidatePipelineDefinitionResponse -> Maybe [ValidationWarning]
validationWarnings} -> Maybe [ValidationWarning]
validationWarnings) (\s :: ValidatePipelineDefinitionResponse
s@ValidatePipelineDefinitionResponse' {} Maybe [ValidationWarning]
a -> ValidatePipelineDefinitionResponse
s {$sel:validationWarnings:ValidatePipelineDefinitionResponse' :: Maybe [ValidationWarning]
validationWarnings = Maybe [ValidationWarning]
a} :: ValidatePipelineDefinitionResponse) 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.
validatePipelineDefinitionResponse_httpStatus :: Lens.Lens' ValidatePipelineDefinitionResponse Prelude.Int
validatePipelineDefinitionResponse_httpStatus :: Lens' ValidatePipelineDefinitionResponse Int
validatePipelineDefinitionResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ValidatePipelineDefinitionResponse' {Int
httpStatus :: Int
$sel:httpStatus:ValidatePipelineDefinitionResponse' :: ValidatePipelineDefinitionResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ValidatePipelineDefinitionResponse
s@ValidatePipelineDefinitionResponse' {} Int
a -> ValidatePipelineDefinitionResponse
s {$sel:httpStatus:ValidatePipelineDefinitionResponse' :: Int
httpStatus = Int
a} :: ValidatePipelineDefinitionResponse)

-- | Indicates whether there were validation errors.
validatePipelineDefinitionResponse_errored :: Lens.Lens' ValidatePipelineDefinitionResponse Prelude.Bool
validatePipelineDefinitionResponse_errored :: Lens' ValidatePipelineDefinitionResponse Bool
validatePipelineDefinitionResponse_errored = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ValidatePipelineDefinitionResponse' {Bool
errored :: Bool
$sel:errored:ValidatePipelineDefinitionResponse' :: ValidatePipelineDefinitionResponse -> Bool
errored} -> Bool
errored) (\s :: ValidatePipelineDefinitionResponse
s@ValidatePipelineDefinitionResponse' {} Bool
a -> ValidatePipelineDefinitionResponse
s {$sel:errored:ValidatePipelineDefinitionResponse' :: Bool
errored = Bool
a} :: ValidatePipelineDefinitionResponse)

instance
  Prelude.NFData
    ValidatePipelineDefinitionResponse
  where
  rnf :: ValidatePipelineDefinitionResponse -> ()
rnf ValidatePipelineDefinitionResponse' {Bool
Int
Maybe [ValidationError]
Maybe [ValidationWarning]
errored :: Bool
httpStatus :: Int
validationWarnings :: Maybe [ValidationWarning]
validationErrors :: Maybe [ValidationError]
$sel:errored:ValidatePipelineDefinitionResponse' :: ValidatePipelineDefinitionResponse -> Bool
$sel:httpStatus:ValidatePipelineDefinitionResponse' :: ValidatePipelineDefinitionResponse -> Int
$sel:validationWarnings:ValidatePipelineDefinitionResponse' :: ValidatePipelineDefinitionResponse -> Maybe [ValidationWarning]
$sel:validationErrors:ValidatePipelineDefinitionResponse' :: ValidatePipelineDefinitionResponse -> 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