{-# 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.CreateVehicle
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a vehicle, which is an instance of a vehicle model (model
-- manifest). Vehicles created from the same vehicle model consist of the
-- same signals inherited from the vehicle model.
--
-- If you have an existing Amazon Web Services IoT Thing, you can use
-- Amazon Web Services IoT FleetWise to create a vehicle and collect data
-- from your thing.
--
-- For more information, see
-- <https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/create-vehicle-cli.html Create a vehicle (AWS CLI)>
-- in the /Amazon Web Services IoT FleetWise Developer Guide/.
module Amazonka.IoTFleetWise.CreateVehicle
  ( -- * Creating a Request
    CreateVehicle (..),
    newCreateVehicle,

    -- * Request Lenses
    createVehicle_associationBehavior,
    createVehicle_attributes,
    createVehicle_tags,
    createVehicle_vehicleName,
    createVehicle_modelManifestArn,
    createVehicle_decoderManifestArn,

    -- * Destructuring the Response
    CreateVehicleResponse (..),
    newCreateVehicleResponse,

    -- * Response Lenses
    createVehicleResponse_arn,
    createVehicleResponse_thingArn,
    createVehicleResponse_vehicleName,
    createVehicleResponse_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:/ 'newCreateVehicle' smart constructor.
data CreateVehicle = CreateVehicle'
  { -- | An option to create a new Amazon Web Services IoT thing when creating a
    -- vehicle, or to validate an existing Amazon Web Services IoT thing as a
    -- vehicle.
    --
    -- Default:
    CreateVehicle -> Maybe VehicleAssociationBehavior
associationBehavior :: Prelude.Maybe VehicleAssociationBehavior,
    -- | Static information about a vehicle in a key-value pair. For example:
    -- @\"engineType\"@ : @\"1.3 L R2\"@
    CreateVehicle -> Maybe (HashMap Text Text)
attributes :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | Metadata that can be used to manage the vehicle.
    CreateVehicle -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The unique ID of the vehicle to create.
    CreateVehicle -> Text
vehicleName :: Prelude.Text,
    -- | The Amazon Resource Name ARN of a vehicle model.
    CreateVehicle -> Text
modelManifestArn :: Prelude.Text,
    -- | The ARN of a decoder manifest.
    CreateVehicle -> Text
decoderManifestArn :: Prelude.Text
  }
  deriving (CreateVehicle -> CreateVehicle -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateVehicle -> CreateVehicle -> Bool
$c/= :: CreateVehicle -> CreateVehicle -> Bool
== :: CreateVehicle -> CreateVehicle -> Bool
$c== :: CreateVehicle -> CreateVehicle -> Bool
Prelude.Eq, ReadPrec [CreateVehicle]
ReadPrec CreateVehicle
Int -> ReadS CreateVehicle
ReadS [CreateVehicle]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateVehicle]
$creadListPrec :: ReadPrec [CreateVehicle]
readPrec :: ReadPrec CreateVehicle
$creadPrec :: ReadPrec CreateVehicle
readList :: ReadS [CreateVehicle]
$creadList :: ReadS [CreateVehicle]
readsPrec :: Int -> ReadS CreateVehicle
$creadsPrec :: Int -> ReadS CreateVehicle
Prelude.Read, Int -> CreateVehicle -> ShowS
[CreateVehicle] -> ShowS
CreateVehicle -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateVehicle] -> ShowS
$cshowList :: [CreateVehicle] -> ShowS
show :: CreateVehicle -> String
$cshow :: CreateVehicle -> String
showsPrec :: Int -> CreateVehicle -> ShowS
$cshowsPrec :: Int -> CreateVehicle -> ShowS
Prelude.Show, forall x. Rep CreateVehicle x -> CreateVehicle
forall x. CreateVehicle -> Rep CreateVehicle x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateVehicle x -> CreateVehicle
$cfrom :: forall x. CreateVehicle -> Rep CreateVehicle x
Prelude.Generic)

-- |
-- Create a value of 'CreateVehicle' 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:
--
-- 'associationBehavior', 'createVehicle_associationBehavior' - An option to create a new Amazon Web Services IoT thing when creating a
-- vehicle, or to validate an existing Amazon Web Services IoT thing as a
-- vehicle.
--
-- Default:
--
-- 'attributes', 'createVehicle_attributes' - Static information about a vehicle in a key-value pair. For example:
-- @\"engineType\"@ : @\"1.3 L R2\"@
--
-- 'tags', 'createVehicle_tags' - Metadata that can be used to manage the vehicle.
--
-- 'vehicleName', 'createVehicle_vehicleName' - The unique ID of the vehicle to create.
--
-- 'modelManifestArn', 'createVehicle_modelManifestArn' - The Amazon Resource Name ARN of a vehicle model.
--
-- 'decoderManifestArn', 'createVehicle_decoderManifestArn' - The ARN of a decoder manifest.
newCreateVehicle ::
  -- | 'vehicleName'
  Prelude.Text ->
  -- | 'modelManifestArn'
  Prelude.Text ->
  -- | 'decoderManifestArn'
  Prelude.Text ->
  CreateVehicle
newCreateVehicle :: Text -> Text -> Text -> CreateVehicle
newCreateVehicle
  Text
pVehicleName_
  Text
pModelManifestArn_
  Text
pDecoderManifestArn_ =
    CreateVehicle'
      { $sel:associationBehavior:CreateVehicle' :: Maybe VehicleAssociationBehavior
associationBehavior =
          forall a. Maybe a
Prelude.Nothing,
        $sel:attributes:CreateVehicle' :: Maybe (HashMap Text Text)
attributes = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateVehicle' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:vehicleName:CreateVehicle' :: Text
vehicleName = Text
pVehicleName_,
        $sel:modelManifestArn:CreateVehicle' :: Text
modelManifestArn = Text
pModelManifestArn_,
        $sel:decoderManifestArn:CreateVehicle' :: Text
decoderManifestArn = Text
pDecoderManifestArn_
      }

-- | An option to create a new Amazon Web Services IoT thing when creating a
-- vehicle, or to validate an existing Amazon Web Services IoT thing as a
-- vehicle.
--
-- Default:
createVehicle_associationBehavior :: Lens.Lens' CreateVehicle (Prelude.Maybe VehicleAssociationBehavior)
createVehicle_associationBehavior :: Lens' CreateVehicle (Maybe VehicleAssociationBehavior)
createVehicle_associationBehavior = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVehicle' {Maybe VehicleAssociationBehavior
associationBehavior :: Maybe VehicleAssociationBehavior
$sel:associationBehavior:CreateVehicle' :: CreateVehicle -> Maybe VehicleAssociationBehavior
associationBehavior} -> Maybe VehicleAssociationBehavior
associationBehavior) (\s :: CreateVehicle
s@CreateVehicle' {} Maybe VehicleAssociationBehavior
a -> CreateVehicle
s {$sel:associationBehavior:CreateVehicle' :: Maybe VehicleAssociationBehavior
associationBehavior = Maybe VehicleAssociationBehavior
a} :: CreateVehicle)

-- | Static information about a vehicle in a key-value pair. For example:
-- @\"engineType\"@ : @\"1.3 L R2\"@
createVehicle_attributes :: Lens.Lens' CreateVehicle (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createVehicle_attributes :: Lens' CreateVehicle (Maybe (HashMap Text Text))
createVehicle_attributes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVehicle' {Maybe (HashMap Text Text)
attributes :: Maybe (HashMap Text Text)
$sel:attributes:CreateVehicle' :: CreateVehicle -> Maybe (HashMap Text Text)
attributes} -> Maybe (HashMap Text Text)
attributes) (\s :: CreateVehicle
s@CreateVehicle' {} Maybe (HashMap Text Text)
a -> CreateVehicle
s {$sel:attributes:CreateVehicle' :: Maybe (HashMap Text Text)
attributes = Maybe (HashMap Text Text)
a} :: CreateVehicle) 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

-- | Metadata that can be used to manage the vehicle.
createVehicle_tags :: Lens.Lens' CreateVehicle (Prelude.Maybe [Tag])
createVehicle_tags :: Lens' CreateVehicle (Maybe [Tag])
createVehicle_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVehicle' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateVehicle' :: CreateVehicle -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateVehicle
s@CreateVehicle' {} Maybe [Tag]
a -> CreateVehicle
s {$sel:tags:CreateVehicle' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateVehicle) 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 unique ID of the vehicle to create.
createVehicle_vehicleName :: Lens.Lens' CreateVehicle Prelude.Text
createVehicle_vehicleName :: Lens' CreateVehicle Text
createVehicle_vehicleName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVehicle' {Text
vehicleName :: Text
$sel:vehicleName:CreateVehicle' :: CreateVehicle -> Text
vehicleName} -> Text
vehicleName) (\s :: CreateVehicle
s@CreateVehicle' {} Text
a -> CreateVehicle
s {$sel:vehicleName:CreateVehicle' :: Text
vehicleName = Text
a} :: CreateVehicle)

-- | The Amazon Resource Name ARN of a vehicle model.
createVehicle_modelManifestArn :: Lens.Lens' CreateVehicle Prelude.Text
createVehicle_modelManifestArn :: Lens' CreateVehicle Text
createVehicle_modelManifestArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVehicle' {Text
modelManifestArn :: Text
$sel:modelManifestArn:CreateVehicle' :: CreateVehicle -> Text
modelManifestArn} -> Text
modelManifestArn) (\s :: CreateVehicle
s@CreateVehicle' {} Text
a -> CreateVehicle
s {$sel:modelManifestArn:CreateVehicle' :: Text
modelManifestArn = Text
a} :: CreateVehicle)

-- | The ARN of a decoder manifest.
createVehicle_decoderManifestArn :: Lens.Lens' CreateVehicle Prelude.Text
createVehicle_decoderManifestArn :: Lens' CreateVehicle Text
createVehicle_decoderManifestArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVehicle' {Text
decoderManifestArn :: Text
$sel:decoderManifestArn:CreateVehicle' :: CreateVehicle -> Text
decoderManifestArn} -> Text
decoderManifestArn) (\s :: CreateVehicle
s@CreateVehicle' {} Text
a -> CreateVehicle
s {$sel:decoderManifestArn:CreateVehicle' :: Text
decoderManifestArn = Text
a} :: CreateVehicle)

instance Core.AWSRequest CreateVehicle where
  type
    AWSResponse CreateVehicle =
      CreateVehicleResponse
  request :: (Service -> Service) -> CreateVehicle -> Request CreateVehicle
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 CreateVehicle
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateVehicle)))
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 -> Maybe Text -> Int -> CreateVehicleResponse
CreateVehicleResponse'
            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
"thingArn")
            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 CreateVehicle where
  hashWithSalt :: Int -> CreateVehicle -> Int
hashWithSalt Int
_salt CreateVehicle' {Maybe [Tag]
Maybe (HashMap Text Text)
Maybe VehicleAssociationBehavior
Text
decoderManifestArn :: Text
modelManifestArn :: Text
vehicleName :: Text
tags :: Maybe [Tag]
attributes :: Maybe (HashMap Text Text)
associationBehavior :: Maybe VehicleAssociationBehavior
$sel:decoderManifestArn:CreateVehicle' :: CreateVehicle -> Text
$sel:modelManifestArn:CreateVehicle' :: CreateVehicle -> Text
$sel:vehicleName:CreateVehicle' :: CreateVehicle -> Text
$sel:tags:CreateVehicle' :: CreateVehicle -> Maybe [Tag]
$sel:attributes:CreateVehicle' :: CreateVehicle -> Maybe (HashMap Text Text)
$sel:associationBehavior:CreateVehicle' :: CreateVehicle -> Maybe VehicleAssociationBehavior
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VehicleAssociationBehavior
associationBehavior
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
attributes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
vehicleName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
modelManifestArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
decoderManifestArn

instance Prelude.NFData CreateVehicle where
  rnf :: CreateVehicle -> ()
rnf CreateVehicle' {Maybe [Tag]
Maybe (HashMap Text Text)
Maybe VehicleAssociationBehavior
Text
decoderManifestArn :: Text
modelManifestArn :: Text
vehicleName :: Text
tags :: Maybe [Tag]
attributes :: Maybe (HashMap Text Text)
associationBehavior :: Maybe VehicleAssociationBehavior
$sel:decoderManifestArn:CreateVehicle' :: CreateVehicle -> Text
$sel:modelManifestArn:CreateVehicle' :: CreateVehicle -> Text
$sel:vehicleName:CreateVehicle' :: CreateVehicle -> Text
$sel:tags:CreateVehicle' :: CreateVehicle -> Maybe [Tag]
$sel:attributes:CreateVehicle' :: CreateVehicle -> Maybe (HashMap Text Text)
$sel:associationBehavior:CreateVehicle' :: CreateVehicle -> Maybe VehicleAssociationBehavior
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe VehicleAssociationBehavior
associationBehavior
      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 [Tag]
tags
      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
modelManifestArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
decoderManifestArn

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

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

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

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

-- |
-- Create a value of 'CreateVehicleResponse' 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', 'createVehicleResponse_arn' - The ARN of the created vehicle.
--
-- 'thingArn', 'createVehicleResponse_thingArn' - The ARN of a created or validated Amazon Web Services IoT thing.
--
-- 'vehicleName', 'createVehicleResponse_vehicleName' - The unique ID of the created vehicle.
--
-- 'httpStatus', 'createVehicleResponse_httpStatus' - The response's http status code.
newCreateVehicleResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateVehicleResponse
newCreateVehicleResponse :: Int -> CreateVehicleResponse
newCreateVehicleResponse Int
pHttpStatus_ =
  CreateVehicleResponse'
    { $sel:arn:CreateVehicleResponse' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:thingArn:CreateVehicleResponse' :: Maybe Text
thingArn = forall a. Maybe a
Prelude.Nothing,
      $sel:vehicleName:CreateVehicleResponse' :: Maybe Text
vehicleName = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateVehicleResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

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

-- | The ARN of a created or validated Amazon Web Services IoT thing.
createVehicleResponse_thingArn :: Lens.Lens' CreateVehicleResponse (Prelude.Maybe Prelude.Text)
createVehicleResponse_thingArn :: Lens' CreateVehicleResponse (Maybe Text)
createVehicleResponse_thingArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVehicleResponse' {Maybe Text
thingArn :: Maybe Text
$sel:thingArn:CreateVehicleResponse' :: CreateVehicleResponse -> Maybe Text
thingArn} -> Maybe Text
thingArn) (\s :: CreateVehicleResponse
s@CreateVehicleResponse' {} Maybe Text
a -> CreateVehicleResponse
s {$sel:thingArn:CreateVehicleResponse' :: Maybe Text
thingArn = Maybe Text
a} :: CreateVehicleResponse)

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

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

instance Prelude.NFData CreateVehicleResponse where
  rnf :: CreateVehicleResponse -> ()
rnf CreateVehicleResponse' {Int
Maybe Text
httpStatus :: Int
vehicleName :: Maybe Text
thingArn :: Maybe Text
arn :: Maybe Text
$sel:httpStatus:CreateVehicleResponse' :: CreateVehicleResponse -> Int
$sel:vehicleName:CreateVehicleResponse' :: CreateVehicleResponse -> Maybe Text
$sel:thingArn:CreateVehicleResponse' :: CreateVehicleResponse -> Maybe Text
$sel:arn:CreateVehicleResponse' :: CreateVehicleResponse -> 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
thingArn
      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