{-# 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.UpdateVehicle
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Updates a vehicle.
module Amazonka.IoTFleetWise.UpdateVehicle
  ( -- * Creating a Request
    UpdateVehicle (..),
    newUpdateVehicle,

    -- * Request Lenses
    updateVehicle_attributeUpdateMode,
    updateVehicle_attributes,
    updateVehicle_decoderManifestArn,
    updateVehicle_modelManifestArn,
    updateVehicle_vehicleName,

    -- * Destructuring the Response
    UpdateVehicleResponse (..),
    newUpdateVehicleResponse,

    -- * Response Lenses
    updateVehicleResponse_arn,
    updateVehicleResponse_vehicleName,
    updateVehicleResponse_httpStatus,
  )
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:/ 'newUpdateVehicle' smart constructor.
data UpdateVehicle = UpdateVehicle'
  { -- | The method the specified attributes will update the existing attributes
    -- on the vehicle. Use@Overwite@ to replace the vehicle attributes with the
    -- specified attributes. Or use @Merge@ to combine all attributes.
    --
    -- This is required if attributes are present in the input.
    UpdateVehicle -> Maybe UpdateMode
attributeUpdateMode :: Prelude.Maybe UpdateMode,
    -- | Static information about a vehicle in a key-value pair. For example:
    --
    -- @\"engineType\"@ : @\"1.3 L R2\"@
    UpdateVehicle -> Maybe (HashMap Text Text)
attributes :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The ARN of the decoder manifest associated with this vehicle.
    UpdateVehicle -> Maybe Text
decoderManifestArn :: Prelude.Maybe Prelude.Text,
    -- | The ARN of a vehicle model (model manifest) associated with the vehicle.
    UpdateVehicle -> Maybe Text
modelManifestArn :: Prelude.Maybe Prelude.Text,
    -- | The unique ID of the vehicle to update.
    UpdateVehicle -> Text
vehicleName :: Prelude.Text
  }
  deriving (UpdateVehicle -> UpdateVehicle -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateVehicle -> UpdateVehicle -> Bool
$c/= :: UpdateVehicle -> UpdateVehicle -> Bool
== :: UpdateVehicle -> UpdateVehicle -> Bool
$c== :: UpdateVehicle -> UpdateVehicle -> Bool
Prelude.Eq, ReadPrec [UpdateVehicle]
ReadPrec UpdateVehicle
Int -> ReadS UpdateVehicle
ReadS [UpdateVehicle]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateVehicle]
$creadListPrec :: ReadPrec [UpdateVehicle]
readPrec :: ReadPrec UpdateVehicle
$creadPrec :: ReadPrec UpdateVehicle
readList :: ReadS [UpdateVehicle]
$creadList :: ReadS [UpdateVehicle]
readsPrec :: Int -> ReadS UpdateVehicle
$creadsPrec :: Int -> ReadS UpdateVehicle
Prelude.Read, Int -> UpdateVehicle -> ShowS
[UpdateVehicle] -> ShowS
UpdateVehicle -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateVehicle] -> ShowS
$cshowList :: [UpdateVehicle] -> ShowS
show :: UpdateVehicle -> String
$cshow :: UpdateVehicle -> String
showsPrec :: Int -> UpdateVehicle -> ShowS
$cshowsPrec :: Int -> UpdateVehicle -> ShowS
Prelude.Show, forall x. Rep UpdateVehicle x -> UpdateVehicle
forall x. UpdateVehicle -> Rep UpdateVehicle x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateVehicle x -> UpdateVehicle
$cfrom :: forall x. UpdateVehicle -> Rep UpdateVehicle x
Prelude.Generic)

-- |
-- Create a value of 'UpdateVehicle' 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:
--
-- 'attributeUpdateMode', 'updateVehicle_attributeUpdateMode' - The method the specified attributes will update the existing attributes
-- on the vehicle. Use@Overwite@ to replace the vehicle attributes with the
-- specified attributes. Or use @Merge@ to combine all attributes.
--
-- This is required if attributes are present in the input.
--
-- 'attributes', 'updateVehicle_attributes' - Static information about a vehicle in a key-value pair. For example:
--
-- @\"engineType\"@ : @\"1.3 L R2\"@
--
-- 'decoderManifestArn', 'updateVehicle_decoderManifestArn' - The ARN of the decoder manifest associated with this vehicle.
--
-- 'modelManifestArn', 'updateVehicle_modelManifestArn' - The ARN of a vehicle model (model manifest) associated with the vehicle.
--
-- 'vehicleName', 'updateVehicle_vehicleName' - The unique ID of the vehicle to update.
newUpdateVehicle ::
  -- | 'vehicleName'
  Prelude.Text ->
  UpdateVehicle
newUpdateVehicle :: Text -> UpdateVehicle
newUpdateVehicle Text
pVehicleName_ =
  UpdateVehicle'
    { $sel:attributeUpdateMode:UpdateVehicle' :: Maybe UpdateMode
attributeUpdateMode =
        forall a. Maybe a
Prelude.Nothing,
      $sel:attributes:UpdateVehicle' :: Maybe (HashMap Text Text)
attributes = forall a. Maybe a
Prelude.Nothing,
      $sel:decoderManifestArn:UpdateVehicle' :: Maybe Text
decoderManifestArn = forall a. Maybe a
Prelude.Nothing,
      $sel:modelManifestArn:UpdateVehicle' :: Maybe Text
modelManifestArn = forall a. Maybe a
Prelude.Nothing,
      $sel:vehicleName:UpdateVehicle' :: Text
vehicleName = Text
pVehicleName_
    }

-- | The method the specified attributes will update the existing attributes
-- on the vehicle. Use@Overwite@ to replace the vehicle attributes with the
-- specified attributes. Or use @Merge@ to combine all attributes.
--
-- This is required if attributes are present in the input.
updateVehicle_attributeUpdateMode :: Lens.Lens' UpdateVehicle (Prelude.Maybe UpdateMode)
updateVehicle_attributeUpdateMode :: Lens' UpdateVehicle (Maybe UpdateMode)
updateVehicle_attributeUpdateMode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVehicle' {Maybe UpdateMode
attributeUpdateMode :: Maybe UpdateMode
$sel:attributeUpdateMode:UpdateVehicle' :: UpdateVehicle -> Maybe UpdateMode
attributeUpdateMode} -> Maybe UpdateMode
attributeUpdateMode) (\s :: UpdateVehicle
s@UpdateVehicle' {} Maybe UpdateMode
a -> UpdateVehicle
s {$sel:attributeUpdateMode:UpdateVehicle' :: Maybe UpdateMode
attributeUpdateMode = Maybe UpdateMode
a} :: UpdateVehicle)

-- | Static information about a vehicle in a key-value pair. For example:
--
-- @\"engineType\"@ : @\"1.3 L R2\"@
updateVehicle_attributes :: Lens.Lens' UpdateVehicle (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
updateVehicle_attributes :: Lens' UpdateVehicle (Maybe (HashMap Text Text))
updateVehicle_attributes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVehicle' {Maybe (HashMap Text Text)
attributes :: Maybe (HashMap Text Text)
$sel:attributes:UpdateVehicle' :: UpdateVehicle -> Maybe (HashMap Text Text)
attributes} -> Maybe (HashMap Text Text)
attributes) (\s :: UpdateVehicle
s@UpdateVehicle' {} Maybe (HashMap Text Text)
a -> UpdateVehicle
s {$sel:attributes:UpdateVehicle' :: Maybe (HashMap Text Text)
attributes = Maybe (HashMap Text Text)
a} :: UpdateVehicle) 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 ARN of the decoder manifest associated with this vehicle.
updateVehicle_decoderManifestArn :: Lens.Lens' UpdateVehicle (Prelude.Maybe Prelude.Text)
updateVehicle_decoderManifestArn :: Lens' UpdateVehicle (Maybe Text)
updateVehicle_decoderManifestArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVehicle' {Maybe Text
decoderManifestArn :: Maybe Text
$sel:decoderManifestArn:UpdateVehicle' :: UpdateVehicle -> Maybe Text
decoderManifestArn} -> Maybe Text
decoderManifestArn) (\s :: UpdateVehicle
s@UpdateVehicle' {} Maybe Text
a -> UpdateVehicle
s {$sel:decoderManifestArn:UpdateVehicle' :: Maybe Text
decoderManifestArn = Maybe Text
a} :: UpdateVehicle)

-- | The ARN of a vehicle model (model manifest) associated with the vehicle.
updateVehicle_modelManifestArn :: Lens.Lens' UpdateVehicle (Prelude.Maybe Prelude.Text)
updateVehicle_modelManifestArn :: Lens' UpdateVehicle (Maybe Text)
updateVehicle_modelManifestArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVehicle' {Maybe Text
modelManifestArn :: Maybe Text
$sel:modelManifestArn:UpdateVehicle' :: UpdateVehicle -> Maybe Text
modelManifestArn} -> Maybe Text
modelManifestArn) (\s :: UpdateVehicle
s@UpdateVehicle' {} Maybe Text
a -> UpdateVehicle
s {$sel:modelManifestArn:UpdateVehicle' :: Maybe Text
modelManifestArn = Maybe Text
a} :: UpdateVehicle)

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

instance Core.AWSRequest UpdateVehicle where
  type
    AWSResponse UpdateVehicle =
      UpdateVehicleResponse
  request :: (Service -> Service) -> UpdateVehicle -> Request UpdateVehicle
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 UpdateVehicle
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse UpdateVehicle)))
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 Text -> Maybe Text -> Int -> UpdateVehicleResponse
UpdateVehicleResponse'
            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
"arn")
            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
"vehicleName")
            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 UpdateVehicle where
  hashWithSalt :: Int -> UpdateVehicle -> Int
hashWithSalt Int
_salt UpdateVehicle' {Maybe Text
Maybe (HashMap Text Text)
Maybe UpdateMode
Text
vehicleName :: Text
modelManifestArn :: Maybe Text
decoderManifestArn :: Maybe Text
attributes :: Maybe (HashMap Text Text)
attributeUpdateMode :: Maybe UpdateMode
$sel:vehicleName:UpdateVehicle' :: UpdateVehicle -> Text
$sel:modelManifestArn:UpdateVehicle' :: UpdateVehicle -> Maybe Text
$sel:decoderManifestArn:UpdateVehicle' :: UpdateVehicle -> Maybe Text
$sel:attributes:UpdateVehicle' :: UpdateVehicle -> Maybe (HashMap Text Text)
$sel:attributeUpdateMode:UpdateVehicle' :: UpdateVehicle -> Maybe UpdateMode
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe UpdateMode
attributeUpdateMode
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
attributes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
decoderManifestArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
modelManifestArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
vehicleName

instance Prelude.NFData UpdateVehicle where
  rnf :: UpdateVehicle -> ()
rnf UpdateVehicle' {Maybe Text
Maybe (HashMap Text Text)
Maybe UpdateMode
Text
vehicleName :: Text
modelManifestArn :: Maybe Text
decoderManifestArn :: Maybe Text
attributes :: Maybe (HashMap Text Text)
attributeUpdateMode :: Maybe UpdateMode
$sel:vehicleName:UpdateVehicle' :: UpdateVehicle -> Text
$sel:modelManifestArn:UpdateVehicle' :: UpdateVehicle -> Maybe Text
$sel:decoderManifestArn:UpdateVehicle' :: UpdateVehicle -> Maybe Text
$sel:attributes:UpdateVehicle' :: UpdateVehicle -> Maybe (HashMap Text Text)
$sel:attributeUpdateMode:UpdateVehicle' :: UpdateVehicle -> Maybe UpdateMode
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe UpdateMode
attributeUpdateMode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
attributes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
decoderManifestArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
modelManifestArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
vehicleName

instance Data.ToHeaders UpdateVehicle where
  toHeaders :: UpdateVehicle -> 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.UpdateVehicle" ::
                          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 UpdateVehicle where
  toJSON :: UpdateVehicle -> Value
toJSON UpdateVehicle' {Maybe Text
Maybe (HashMap Text Text)
Maybe UpdateMode
Text
vehicleName :: Text
modelManifestArn :: Maybe Text
decoderManifestArn :: Maybe Text
attributes :: Maybe (HashMap Text Text)
attributeUpdateMode :: Maybe UpdateMode
$sel:vehicleName:UpdateVehicle' :: UpdateVehicle -> Text
$sel:modelManifestArn:UpdateVehicle' :: UpdateVehicle -> Maybe Text
$sel:decoderManifestArn:UpdateVehicle' :: UpdateVehicle -> Maybe Text
$sel:attributes:UpdateVehicle' :: UpdateVehicle -> Maybe (HashMap Text Text)
$sel:attributeUpdateMode:UpdateVehicle' :: UpdateVehicle -> Maybe UpdateMode
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"attributeUpdateMode" 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 UpdateMode
attributeUpdateMode,
            (Key
"attributes" 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 (HashMap Text Text)
attributes,
            (Key
"decoderManifestArn" 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 Text
decoderManifestArn,
            (Key
"modelManifestArn" 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 Text
modelManifestArn,
            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 UpdateVehicle where
  toPath :: UpdateVehicle -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

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

-- |
-- Create a value of 'UpdateVehicleResponse' 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:
--
-- 'arn', 'updateVehicleResponse_arn' - The ARN of the updated vehicle.
--
-- 'vehicleName', 'updateVehicleResponse_vehicleName' - The ID of the updated vehicle.
--
-- 'httpStatus', 'updateVehicleResponse_httpStatus' - The response's http status code.
newUpdateVehicleResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateVehicleResponse
newUpdateVehicleResponse :: Int -> UpdateVehicleResponse
newUpdateVehicleResponse Int
pHttpStatus_ =
  UpdateVehicleResponse'
    { $sel:arn:UpdateVehicleResponse' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:vehicleName:UpdateVehicleResponse' :: Maybe Text
vehicleName = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateVehicleResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the updated vehicle.
updateVehicleResponse_arn :: Lens.Lens' UpdateVehicleResponse (Prelude.Maybe Prelude.Text)
updateVehicleResponse_arn :: Lens' UpdateVehicleResponse (Maybe Text)
updateVehicleResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVehicleResponse' {Maybe Text
arn :: Maybe Text
$sel:arn:UpdateVehicleResponse' :: UpdateVehicleResponse -> Maybe Text
arn} -> Maybe Text
arn) (\s :: UpdateVehicleResponse
s@UpdateVehicleResponse' {} Maybe Text
a -> UpdateVehicleResponse
s {$sel:arn:UpdateVehicleResponse' :: Maybe Text
arn = Maybe Text
a} :: UpdateVehicleResponse)

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

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

instance Prelude.NFData UpdateVehicleResponse where
  rnf :: UpdateVehicleResponse -> ()
rnf UpdateVehicleResponse' {Int
Maybe Text
httpStatus :: Int
vehicleName :: Maybe Text
arn :: Maybe Text
$sel:httpStatus:UpdateVehicleResponse' :: UpdateVehicleResponse -> Int
$sel:vehicleName:UpdateVehicleResponse' :: UpdateVehicleResponse -> Maybe Text
$sel:arn:UpdateVehicleResponse' :: UpdateVehicleResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
vehicleName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus