{-# 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.IoTFleetWise.DeleteVehicle
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes a vehicle and removes it from any campaigns.
--
-- If the vehicle is successfully deleted, Amazon Web Services IoT
-- FleetWise sends back an HTTP 200 response with an empty body.
module Amazonka.IoTFleetWise.DeleteVehicle
  ( -- * Creating a Request
    DeleteVehicle (..),
    newDeleteVehicle,

    -- * Request Lenses
    deleteVehicle_vehicleName,

    -- * Destructuring the Response
    DeleteVehicleResponse (..),
    newDeleteVehicleResponse,

    -- * Response Lenses
    deleteVehicleResponse_httpStatus,
    deleteVehicleResponse_vehicleName,
    deleteVehicleResponse_arn,
  )
where

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

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

-- |
-- Create a value of 'DeleteVehicle' 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:
--
-- 'vehicleName', 'deleteVehicle_vehicleName' - The ID of the vehicle to delete.
newDeleteVehicle ::
  -- | 'vehicleName'
  Prelude.Text ->
  DeleteVehicle
newDeleteVehicle :: Text -> DeleteVehicle
newDeleteVehicle Text
pVehicleName_ =
  DeleteVehicle' {$sel:vehicleName:DeleteVehicle' :: Text
vehicleName = Text
pVehicleName_}

-- | The ID of the vehicle to delete.
deleteVehicle_vehicleName :: Lens.Lens' DeleteVehicle Prelude.Text
deleteVehicle_vehicleName :: Lens' DeleteVehicle Text
deleteVehicle_vehicleName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteVehicle' {Text
vehicleName :: Text
$sel:vehicleName:DeleteVehicle' :: DeleteVehicle -> Text
vehicleName} -> Text
vehicleName) (\s :: DeleteVehicle
s@DeleteVehicle' {} Text
a -> DeleteVehicle
s {$sel:vehicleName:DeleteVehicle' :: Text
vehicleName = Text
a} :: DeleteVehicle)

instance Core.AWSRequest DeleteVehicle where
  type
    AWSResponse DeleteVehicle =
      DeleteVehicleResponse
  request :: (Service -> Service) -> DeleteVehicle -> Request DeleteVehicle
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 DeleteVehicle
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DeleteVehicle)))
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 ->
          Int -> Text -> Text -> DeleteVehicleResponse
DeleteVehicleResponse'
            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))
            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
"vehicleName")
            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
"arn")
      )

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

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

instance Data.ToHeaders DeleteVehicle where
  toHeaders :: DeleteVehicle -> 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
"IoTAutobahnControlPlane.DeleteVehicle" ::
                          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 DeleteVehicle where
  toJSON :: DeleteVehicle -> Value
toJSON DeleteVehicle' {Text
vehicleName :: Text
$sel:vehicleName:DeleteVehicle' :: DeleteVehicle -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [forall a. a -> Maybe a
Prelude.Just (Key
"vehicleName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
vehicleName)]
      )

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

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

-- | /See:/ 'newDeleteVehicleResponse' smart constructor.
data DeleteVehicleResponse = DeleteVehicleResponse'
  { -- | The response's http status code.
    DeleteVehicleResponse -> Int
httpStatus :: Prelude.Int,
    -- | The ID of the deleted vehicle.
    DeleteVehicleResponse -> Text
vehicleName :: Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the deleted vehicle.
    DeleteVehicleResponse -> Text
arn :: Prelude.Text
  }
  deriving (DeleteVehicleResponse -> DeleteVehicleResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteVehicleResponse -> DeleteVehicleResponse -> Bool
$c/= :: DeleteVehicleResponse -> DeleteVehicleResponse -> Bool
== :: DeleteVehicleResponse -> DeleteVehicleResponse -> Bool
$c== :: DeleteVehicleResponse -> DeleteVehicleResponse -> Bool
Prelude.Eq, ReadPrec [DeleteVehicleResponse]
ReadPrec DeleteVehicleResponse
Int -> ReadS DeleteVehicleResponse
ReadS [DeleteVehicleResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteVehicleResponse]
$creadListPrec :: ReadPrec [DeleteVehicleResponse]
readPrec :: ReadPrec DeleteVehicleResponse
$creadPrec :: ReadPrec DeleteVehicleResponse
readList :: ReadS [DeleteVehicleResponse]
$creadList :: ReadS [DeleteVehicleResponse]
readsPrec :: Int -> ReadS DeleteVehicleResponse
$creadsPrec :: Int -> ReadS DeleteVehicleResponse
Prelude.Read, Int -> DeleteVehicleResponse -> ShowS
[DeleteVehicleResponse] -> ShowS
DeleteVehicleResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteVehicleResponse] -> ShowS
$cshowList :: [DeleteVehicleResponse] -> ShowS
show :: DeleteVehicleResponse -> String
$cshow :: DeleteVehicleResponse -> String
showsPrec :: Int -> DeleteVehicleResponse -> ShowS
$cshowsPrec :: Int -> DeleteVehicleResponse -> ShowS
Prelude.Show, forall x. Rep DeleteVehicleResponse x -> DeleteVehicleResponse
forall x. DeleteVehicleResponse -> Rep DeleteVehicleResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteVehicleResponse x -> DeleteVehicleResponse
$cfrom :: forall x. DeleteVehicleResponse -> Rep DeleteVehicleResponse x
Prelude.Generic)

-- |
-- Create a value of 'DeleteVehicleResponse' 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', 'deleteVehicleResponse_httpStatus' - The response's http status code.
--
-- 'vehicleName', 'deleteVehicleResponse_vehicleName' - The ID of the deleted vehicle.
--
-- 'arn', 'deleteVehicleResponse_arn' - The Amazon Resource Name (ARN) of the deleted vehicle.
newDeleteVehicleResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'vehicleName'
  Prelude.Text ->
  -- | 'arn'
  Prelude.Text ->
  DeleteVehicleResponse
newDeleteVehicleResponse :: Int -> Text -> Text -> DeleteVehicleResponse
newDeleteVehicleResponse
  Int
pHttpStatus_
  Text
pVehicleName_
  Text
pArn_ =
    DeleteVehicleResponse'
      { $sel:httpStatus:DeleteVehicleResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:vehicleName:DeleteVehicleResponse' :: Text
vehicleName = Text
pVehicleName_,
        $sel:arn:DeleteVehicleResponse' :: Text
arn = Text
pArn_
      }

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

-- | The ID of the deleted vehicle.
deleteVehicleResponse_vehicleName :: Lens.Lens' DeleteVehicleResponse Prelude.Text
deleteVehicleResponse_vehicleName :: Lens' DeleteVehicleResponse Text
deleteVehicleResponse_vehicleName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteVehicleResponse' {Text
vehicleName :: Text
$sel:vehicleName:DeleteVehicleResponse' :: DeleteVehicleResponse -> Text
vehicleName} -> Text
vehicleName) (\s :: DeleteVehicleResponse
s@DeleteVehicleResponse' {} Text
a -> DeleteVehicleResponse
s {$sel:vehicleName:DeleteVehicleResponse' :: Text
vehicleName = Text
a} :: DeleteVehicleResponse)

-- | The Amazon Resource Name (ARN) of the deleted vehicle.
deleteVehicleResponse_arn :: Lens.Lens' DeleteVehicleResponse Prelude.Text
deleteVehicleResponse_arn :: Lens' DeleteVehicleResponse Text
deleteVehicleResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteVehicleResponse' {Text
arn :: Text
$sel:arn:DeleteVehicleResponse' :: DeleteVehicleResponse -> Text
arn} -> Text
arn) (\s :: DeleteVehicleResponse
s@DeleteVehicleResponse' {} Text
a -> DeleteVehicleResponse
s {$sel:arn:DeleteVehicleResponse' :: Text
arn = Text
a} :: DeleteVehicleResponse)

instance Prelude.NFData DeleteVehicleResponse where
  rnf :: DeleteVehicleResponse -> ()
rnf DeleteVehicleResponse' {Int
Text
arn :: Text
vehicleName :: Text
httpStatus :: Int
$sel:arn:DeleteVehicleResponse' :: DeleteVehicleResponse -> Text
$sel:vehicleName:DeleteVehicleResponse' :: DeleteVehicleResponse -> Text
$sel:httpStatus:DeleteVehicleResponse' :: DeleteVehicleResponse -> Int
..} =
    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 Text
vehicleName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
arn