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

    -- * Request Lenses
    associateVehicleFleet_vehicleName,
    associateVehicleFleet_fleetId,

    -- * Destructuring the Response
    AssociateVehicleFleetResponse (..),
    newAssociateVehicleFleetResponse,

    -- * Response Lenses
    associateVehicleFleetResponse_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:/ 'newAssociateVehicleFleet' smart constructor.
data AssociateVehicleFleet = AssociateVehicleFleet'
  { -- | The unique ID of the vehicle to associate with the fleet.
    AssociateVehicleFleet -> Text
vehicleName :: Prelude.Text,
    -- | The ID of a fleet.
    AssociateVehicleFleet -> Text
fleetId :: Prelude.Text
  }
  deriving (AssociateVehicleFleet -> AssociateVehicleFleet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssociateVehicleFleet -> AssociateVehicleFleet -> Bool
$c/= :: AssociateVehicleFleet -> AssociateVehicleFleet -> Bool
== :: AssociateVehicleFleet -> AssociateVehicleFleet -> Bool
$c== :: AssociateVehicleFleet -> AssociateVehicleFleet -> Bool
Prelude.Eq, ReadPrec [AssociateVehicleFleet]
ReadPrec AssociateVehicleFleet
Int -> ReadS AssociateVehicleFleet
ReadS [AssociateVehicleFleet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AssociateVehicleFleet]
$creadListPrec :: ReadPrec [AssociateVehicleFleet]
readPrec :: ReadPrec AssociateVehicleFleet
$creadPrec :: ReadPrec AssociateVehicleFleet
readList :: ReadS [AssociateVehicleFleet]
$creadList :: ReadS [AssociateVehicleFleet]
readsPrec :: Int -> ReadS AssociateVehicleFleet
$creadsPrec :: Int -> ReadS AssociateVehicleFleet
Prelude.Read, Int -> AssociateVehicleFleet -> ShowS
[AssociateVehicleFleet] -> ShowS
AssociateVehicleFleet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssociateVehicleFleet] -> ShowS
$cshowList :: [AssociateVehicleFleet] -> ShowS
show :: AssociateVehicleFleet -> String
$cshow :: AssociateVehicleFleet -> String
showsPrec :: Int -> AssociateVehicleFleet -> ShowS
$cshowsPrec :: Int -> AssociateVehicleFleet -> ShowS
Prelude.Show, forall x. Rep AssociateVehicleFleet x -> AssociateVehicleFleet
forall x. AssociateVehicleFleet -> Rep AssociateVehicleFleet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AssociateVehicleFleet x -> AssociateVehicleFleet
$cfrom :: forall x. AssociateVehicleFleet -> Rep AssociateVehicleFleet x
Prelude.Generic)

-- |
-- Create a value of 'AssociateVehicleFleet' 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', 'associateVehicleFleet_vehicleName' - The unique ID of the vehicle to associate with the fleet.
--
-- 'fleetId', 'associateVehicleFleet_fleetId' - The ID of a fleet.
newAssociateVehicleFleet ::
  -- | 'vehicleName'
  Prelude.Text ->
  -- | 'fleetId'
  Prelude.Text ->
  AssociateVehicleFleet
newAssociateVehicleFleet :: Text -> Text -> AssociateVehicleFleet
newAssociateVehicleFleet Text
pVehicleName_ Text
pFleetId_ =
  AssociateVehicleFleet'
    { $sel:vehicleName:AssociateVehicleFleet' :: Text
vehicleName = Text
pVehicleName_,
      $sel:fleetId:AssociateVehicleFleet' :: Text
fleetId = Text
pFleetId_
    }

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

-- | The ID of a fleet.
associateVehicleFleet_fleetId :: Lens.Lens' AssociateVehicleFleet Prelude.Text
associateVehicleFleet_fleetId :: Lens' AssociateVehicleFleet Text
associateVehicleFleet_fleetId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateVehicleFleet' {Text
fleetId :: Text
$sel:fleetId:AssociateVehicleFleet' :: AssociateVehicleFleet -> Text
fleetId} -> Text
fleetId) (\s :: AssociateVehicleFleet
s@AssociateVehicleFleet' {} Text
a -> AssociateVehicleFleet
s {$sel:fleetId:AssociateVehicleFleet' :: Text
fleetId = Text
a} :: AssociateVehicleFleet)

instance Core.AWSRequest AssociateVehicleFleet where
  type
    AWSResponse AssociateVehicleFleet =
      AssociateVehicleFleetResponse
  request :: (Service -> Service)
-> AssociateVehicleFleet -> Request AssociateVehicleFleet
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 AssociateVehicleFleet
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse AssociateVehicleFleet)))
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 -> AssociateVehicleFleetResponse
AssociateVehicleFleetResponse'
            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 AssociateVehicleFleet where
  hashWithSalt :: Int -> AssociateVehicleFleet -> Int
hashWithSalt Int
_salt AssociateVehicleFleet' {Text
fleetId :: Text
vehicleName :: Text
$sel:fleetId:AssociateVehicleFleet' :: AssociateVehicleFleet -> Text
$sel:vehicleName:AssociateVehicleFleet' :: AssociateVehicleFleet -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
vehicleName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
fleetId

instance Prelude.NFData AssociateVehicleFleet where
  rnf :: AssociateVehicleFleet -> ()
rnf AssociateVehicleFleet' {Text
fleetId :: Text
vehicleName :: Text
$sel:fleetId:AssociateVehicleFleet' :: AssociateVehicleFleet -> Text
$sel:vehicleName:AssociateVehicleFleet' :: AssociateVehicleFleet -> Text
..} =
    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
fleetId

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

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

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

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

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

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

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