{-# 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.Proton.DeleteEnvironmentTemplate
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- If no other major or minor versions of an environment template exist,
-- delete the environment template.
module Amazonka.Proton.DeleteEnvironmentTemplate
  ( -- * Creating a Request
    DeleteEnvironmentTemplate (..),
    newDeleteEnvironmentTemplate,

    -- * Request Lenses
    deleteEnvironmentTemplate_name,

    -- * Destructuring the Response
    DeleteEnvironmentTemplateResponse (..),
    newDeleteEnvironmentTemplateResponse,

    -- * Response Lenses
    deleteEnvironmentTemplateResponse_environmentTemplate,
    deleteEnvironmentTemplateResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDeleteEnvironmentTemplate' smart constructor.
data DeleteEnvironmentTemplate = DeleteEnvironmentTemplate'
  { -- | The name of the environment template to delete.
    DeleteEnvironmentTemplate -> Text
name :: Prelude.Text
  }
  deriving (DeleteEnvironmentTemplate -> DeleteEnvironmentTemplate -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteEnvironmentTemplate -> DeleteEnvironmentTemplate -> Bool
$c/= :: DeleteEnvironmentTemplate -> DeleteEnvironmentTemplate -> Bool
== :: DeleteEnvironmentTemplate -> DeleteEnvironmentTemplate -> Bool
$c== :: DeleteEnvironmentTemplate -> DeleteEnvironmentTemplate -> Bool
Prelude.Eq, ReadPrec [DeleteEnvironmentTemplate]
ReadPrec DeleteEnvironmentTemplate
Int -> ReadS DeleteEnvironmentTemplate
ReadS [DeleteEnvironmentTemplate]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteEnvironmentTemplate]
$creadListPrec :: ReadPrec [DeleteEnvironmentTemplate]
readPrec :: ReadPrec DeleteEnvironmentTemplate
$creadPrec :: ReadPrec DeleteEnvironmentTemplate
readList :: ReadS [DeleteEnvironmentTemplate]
$creadList :: ReadS [DeleteEnvironmentTemplate]
readsPrec :: Int -> ReadS DeleteEnvironmentTemplate
$creadsPrec :: Int -> ReadS DeleteEnvironmentTemplate
Prelude.Read, Int -> DeleteEnvironmentTemplate -> ShowS
[DeleteEnvironmentTemplate] -> ShowS
DeleteEnvironmentTemplate -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteEnvironmentTemplate] -> ShowS
$cshowList :: [DeleteEnvironmentTemplate] -> ShowS
show :: DeleteEnvironmentTemplate -> String
$cshow :: DeleteEnvironmentTemplate -> String
showsPrec :: Int -> DeleteEnvironmentTemplate -> ShowS
$cshowsPrec :: Int -> DeleteEnvironmentTemplate -> ShowS
Prelude.Show, forall x.
Rep DeleteEnvironmentTemplate x -> DeleteEnvironmentTemplate
forall x.
DeleteEnvironmentTemplate -> Rep DeleteEnvironmentTemplate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DeleteEnvironmentTemplate x -> DeleteEnvironmentTemplate
$cfrom :: forall x.
DeleteEnvironmentTemplate -> Rep DeleteEnvironmentTemplate x
Prelude.Generic)

-- |
-- Create a value of 'DeleteEnvironmentTemplate' 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:
--
-- 'name', 'deleteEnvironmentTemplate_name' - The name of the environment template to delete.
newDeleteEnvironmentTemplate ::
  -- | 'name'
  Prelude.Text ->
  DeleteEnvironmentTemplate
newDeleteEnvironmentTemplate :: Text -> DeleteEnvironmentTemplate
newDeleteEnvironmentTemplate Text
pName_ =
  DeleteEnvironmentTemplate' {$sel:name:DeleteEnvironmentTemplate' :: Text
name = Text
pName_}

-- | The name of the environment template to delete.
deleteEnvironmentTemplate_name :: Lens.Lens' DeleteEnvironmentTemplate Prelude.Text
deleteEnvironmentTemplate_name :: Lens' DeleteEnvironmentTemplate Text
deleteEnvironmentTemplate_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteEnvironmentTemplate' {Text
name :: Text
$sel:name:DeleteEnvironmentTemplate' :: DeleteEnvironmentTemplate -> Text
name} -> Text
name) (\s :: DeleteEnvironmentTemplate
s@DeleteEnvironmentTemplate' {} Text
a -> DeleteEnvironmentTemplate
s {$sel:name:DeleteEnvironmentTemplate' :: Text
name = Text
a} :: DeleteEnvironmentTemplate)

instance Core.AWSRequest DeleteEnvironmentTemplate where
  type
    AWSResponse DeleteEnvironmentTemplate =
      DeleteEnvironmentTemplateResponse
  request :: (Service -> Service)
-> DeleteEnvironmentTemplate -> Request DeleteEnvironmentTemplate
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 DeleteEnvironmentTemplate
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DeleteEnvironmentTemplate)))
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 EnvironmentTemplate
-> Int -> DeleteEnvironmentTemplateResponse
DeleteEnvironmentTemplateResponse'
            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
"environmentTemplate")
            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))
      )

instance Prelude.Hashable DeleteEnvironmentTemplate where
  hashWithSalt :: Int -> DeleteEnvironmentTemplate -> Int
hashWithSalt Int
_salt DeleteEnvironmentTemplate' {Text
name :: Text
$sel:name:DeleteEnvironmentTemplate' :: DeleteEnvironmentTemplate -> Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData DeleteEnvironmentTemplate where
  rnf :: DeleteEnvironmentTemplate -> ()
rnf DeleteEnvironmentTemplate' {Text
name :: Text
$sel:name:DeleteEnvironmentTemplate' :: DeleteEnvironmentTemplate -> Text
..} = forall a. NFData a => a -> ()
Prelude.rnf Text
name

instance Data.ToHeaders DeleteEnvironmentTemplate where
  toHeaders :: DeleteEnvironmentTemplate -> 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
"AwsProton20200720.DeleteEnvironmentTemplate" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON DeleteEnvironmentTemplate where
  toJSON :: DeleteEnvironmentTemplate -> Value
toJSON DeleteEnvironmentTemplate' {Text
name :: Text
$sel:name:DeleteEnvironmentTemplate' :: DeleteEnvironmentTemplate -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [forall a. a -> Maybe a
Prelude.Just (Key
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)]
      )

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

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

-- | /See:/ 'newDeleteEnvironmentTemplateResponse' smart constructor.
data DeleteEnvironmentTemplateResponse = DeleteEnvironmentTemplateResponse'
  { -- | The detailed data of the environment template being deleted.
    DeleteEnvironmentTemplateResponse -> Maybe EnvironmentTemplate
environmentTemplate :: Prelude.Maybe EnvironmentTemplate,
    -- | The response's http status code.
    DeleteEnvironmentTemplateResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DeleteEnvironmentTemplateResponse
-> DeleteEnvironmentTemplateResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteEnvironmentTemplateResponse
-> DeleteEnvironmentTemplateResponse -> Bool
$c/= :: DeleteEnvironmentTemplateResponse
-> DeleteEnvironmentTemplateResponse -> Bool
== :: DeleteEnvironmentTemplateResponse
-> DeleteEnvironmentTemplateResponse -> Bool
$c== :: DeleteEnvironmentTemplateResponse
-> DeleteEnvironmentTemplateResponse -> Bool
Prelude.Eq, Int -> DeleteEnvironmentTemplateResponse -> ShowS
[DeleteEnvironmentTemplateResponse] -> ShowS
DeleteEnvironmentTemplateResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteEnvironmentTemplateResponse] -> ShowS
$cshowList :: [DeleteEnvironmentTemplateResponse] -> ShowS
show :: DeleteEnvironmentTemplateResponse -> String
$cshow :: DeleteEnvironmentTemplateResponse -> String
showsPrec :: Int -> DeleteEnvironmentTemplateResponse -> ShowS
$cshowsPrec :: Int -> DeleteEnvironmentTemplateResponse -> ShowS
Prelude.Show, forall x.
Rep DeleteEnvironmentTemplateResponse x
-> DeleteEnvironmentTemplateResponse
forall x.
DeleteEnvironmentTemplateResponse
-> Rep DeleteEnvironmentTemplateResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DeleteEnvironmentTemplateResponse x
-> DeleteEnvironmentTemplateResponse
$cfrom :: forall x.
DeleteEnvironmentTemplateResponse
-> Rep DeleteEnvironmentTemplateResponse x
Prelude.Generic)

-- |
-- Create a value of 'DeleteEnvironmentTemplateResponse' 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:
--
-- 'environmentTemplate', 'deleteEnvironmentTemplateResponse_environmentTemplate' - The detailed data of the environment template being deleted.
--
-- 'httpStatus', 'deleteEnvironmentTemplateResponse_httpStatus' - The response's http status code.
newDeleteEnvironmentTemplateResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteEnvironmentTemplateResponse
newDeleteEnvironmentTemplateResponse :: Int -> DeleteEnvironmentTemplateResponse
newDeleteEnvironmentTemplateResponse Int
pHttpStatus_ =
  DeleteEnvironmentTemplateResponse'
    { $sel:environmentTemplate:DeleteEnvironmentTemplateResponse' :: Maybe EnvironmentTemplate
environmentTemplate =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DeleteEnvironmentTemplateResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The detailed data of the environment template being deleted.
deleteEnvironmentTemplateResponse_environmentTemplate :: Lens.Lens' DeleteEnvironmentTemplateResponse (Prelude.Maybe EnvironmentTemplate)
deleteEnvironmentTemplateResponse_environmentTemplate :: Lens' DeleteEnvironmentTemplateResponse (Maybe EnvironmentTemplate)
deleteEnvironmentTemplateResponse_environmentTemplate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteEnvironmentTemplateResponse' {Maybe EnvironmentTemplate
environmentTemplate :: Maybe EnvironmentTemplate
$sel:environmentTemplate:DeleteEnvironmentTemplateResponse' :: DeleteEnvironmentTemplateResponse -> Maybe EnvironmentTemplate
environmentTemplate} -> Maybe EnvironmentTemplate
environmentTemplate) (\s :: DeleteEnvironmentTemplateResponse
s@DeleteEnvironmentTemplateResponse' {} Maybe EnvironmentTemplate
a -> DeleteEnvironmentTemplateResponse
s {$sel:environmentTemplate:DeleteEnvironmentTemplateResponse' :: Maybe EnvironmentTemplate
environmentTemplate = Maybe EnvironmentTemplate
a} :: DeleteEnvironmentTemplateResponse)

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

instance
  Prelude.NFData
    DeleteEnvironmentTemplateResponse
  where
  rnf :: DeleteEnvironmentTemplateResponse -> ()
rnf DeleteEnvironmentTemplateResponse' {Int
Maybe EnvironmentTemplate
httpStatus :: Int
environmentTemplate :: Maybe EnvironmentTemplate
$sel:httpStatus:DeleteEnvironmentTemplateResponse' :: DeleteEnvironmentTemplateResponse -> Int
$sel:environmentTemplate:DeleteEnvironmentTemplateResponse' :: DeleteEnvironmentTemplateResponse -> Maybe EnvironmentTemplate
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe EnvironmentTemplate
environmentTemplate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus