{-# 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.IoTRoboRunner.DeleteWorker
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Grants permission to delete a worker
module Amazonka.IoTRoboRunner.DeleteWorker
  ( -- * Creating a Request
    DeleteWorker (..),
    newDeleteWorker,

    -- * Request Lenses
    deleteWorker_id,

    -- * Destructuring the Response
    DeleteWorkerResponse (..),
    newDeleteWorkerResponse,

    -- * Response Lenses
    deleteWorkerResponse_httpStatus,
  )
where

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

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

-- |
-- Create a value of 'DeleteWorker' 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:
--
-- 'id', 'deleteWorker_id' - Undocumented member.
newDeleteWorker ::
  -- | 'id'
  Prelude.Text ->
  DeleteWorker
newDeleteWorker :: Text -> DeleteWorker
newDeleteWorker Text
pId_ = DeleteWorker' {$sel:id:DeleteWorker' :: Text
id = Text
pId_}

-- | Undocumented member.
deleteWorker_id :: Lens.Lens' DeleteWorker Prelude.Text
deleteWorker_id :: Lens' DeleteWorker Text
deleteWorker_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteWorker' {Text
id :: Text
$sel:id:DeleteWorker' :: DeleteWorker -> Text
id} -> Text
id) (\s :: DeleteWorker
s@DeleteWorker' {} Text
a -> DeleteWorker
s {$sel:id:DeleteWorker' :: Text
id = Text
a} :: DeleteWorker)

instance Core.AWSRequest DeleteWorker where
  type AWSResponse DeleteWorker = DeleteWorkerResponse
  request :: (Service -> Service) -> DeleteWorker -> Request DeleteWorker
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 DeleteWorker
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DeleteWorker)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> DeleteWorkerResponse
DeleteWorkerResponse'
            forall (f :: * -> *) a b. Functor 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 DeleteWorker where
  hashWithSalt :: Int -> DeleteWorker -> Int
hashWithSalt Int
_salt DeleteWorker' {Text
id :: Text
$sel:id:DeleteWorker' :: DeleteWorker -> Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
id

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

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

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

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

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

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

-- |
-- Create a value of 'DeleteWorkerResponse' 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:
--
-- 'httpStatus', 'deleteWorkerResponse_httpStatus' - The response's http status code.
newDeleteWorkerResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteWorkerResponse
newDeleteWorkerResponse :: Int -> DeleteWorkerResponse
newDeleteWorkerResponse Int
pHttpStatus_ =
  DeleteWorkerResponse' {$sel:httpStatus:DeleteWorkerResponse' :: Int
httpStatus = Int
pHttpStatus_}

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

instance Prelude.NFData DeleteWorkerResponse where
  rnf :: DeleteWorkerResponse -> ()
rnf DeleteWorkerResponse' {Int
httpStatus :: Int
$sel:httpStatus:DeleteWorkerResponse' :: DeleteWorkerResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus