{-# 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.CreateFleet
-- 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 fleet that represents a group of vehicles.
--
-- You must create both a signal catalog and vehicles before you can create
-- a fleet.
--
-- For more information, see
-- <https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/fleets.html Fleets>
-- in the /Amazon Web Services IoT FleetWise Developer Guide/.
module Amazonka.IoTFleetWise.CreateFleet
  ( -- * Creating a Request
    CreateFleet (..),
    newCreateFleet,

    -- * Request Lenses
    createFleet_description,
    createFleet_tags,
    createFleet_fleetId,
    createFleet_signalCatalogArn,

    -- * Destructuring the Response
    CreateFleetResponse (..),
    newCreateFleetResponse,

    -- * Response Lenses
    createFleetResponse_httpStatus,
    createFleetResponse_id,
    createFleetResponse_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:/ 'newCreateFleet' smart constructor.
data CreateFleet = CreateFleet'
  { -- | A brief description of the fleet to create.
    CreateFleet -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Metadata that can be used to manage the fleet.
    CreateFleet -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The unique ID of the fleet to create.
    CreateFleet -> Text
fleetId :: Prelude.Text,
    -- | The Amazon Resource Name (ARN) of a signal catalog.
    CreateFleet -> Text
signalCatalogArn :: Prelude.Text
  }
  deriving (CreateFleet -> CreateFleet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateFleet -> CreateFleet -> Bool
$c/= :: CreateFleet -> CreateFleet -> Bool
== :: CreateFleet -> CreateFleet -> Bool
$c== :: CreateFleet -> CreateFleet -> Bool
Prelude.Eq, ReadPrec [CreateFleet]
ReadPrec CreateFleet
Int -> ReadS CreateFleet
ReadS [CreateFleet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateFleet]
$creadListPrec :: ReadPrec [CreateFleet]
readPrec :: ReadPrec CreateFleet
$creadPrec :: ReadPrec CreateFleet
readList :: ReadS [CreateFleet]
$creadList :: ReadS [CreateFleet]
readsPrec :: Int -> ReadS CreateFleet
$creadsPrec :: Int -> ReadS CreateFleet
Prelude.Read, Int -> CreateFleet -> ShowS
[CreateFleet] -> ShowS
CreateFleet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateFleet] -> ShowS
$cshowList :: [CreateFleet] -> ShowS
show :: CreateFleet -> String
$cshow :: CreateFleet -> String
showsPrec :: Int -> CreateFleet -> ShowS
$cshowsPrec :: Int -> CreateFleet -> ShowS
Prelude.Show, forall x. Rep CreateFleet x -> CreateFleet
forall x. CreateFleet -> Rep CreateFleet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateFleet x -> CreateFleet
$cfrom :: forall x. CreateFleet -> Rep CreateFleet x
Prelude.Generic)

-- |
-- Create a value of 'CreateFleet' 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:
--
-- 'description', 'createFleet_description' - A brief description of the fleet to create.
--
-- 'tags', 'createFleet_tags' - Metadata that can be used to manage the fleet.
--
-- 'fleetId', 'createFleet_fleetId' - The unique ID of the fleet to create.
--
-- 'signalCatalogArn', 'createFleet_signalCatalogArn' - The Amazon Resource Name (ARN) of a signal catalog.
newCreateFleet ::
  -- | 'fleetId'
  Prelude.Text ->
  -- | 'signalCatalogArn'
  Prelude.Text ->
  CreateFleet
newCreateFleet :: Text -> Text -> CreateFleet
newCreateFleet Text
pFleetId_ Text
pSignalCatalogArn_ =
  CreateFleet'
    { $sel:description:CreateFleet' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateFleet' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:fleetId:CreateFleet' :: Text
fleetId = Text
pFleetId_,
      $sel:signalCatalogArn:CreateFleet' :: Text
signalCatalogArn = Text
pSignalCatalogArn_
    }

-- | A brief description of the fleet to create.
createFleet_description :: Lens.Lens' CreateFleet (Prelude.Maybe Prelude.Text)
createFleet_description :: Lens' CreateFleet (Maybe Text)
createFleet_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe Text
description :: Maybe Text
$sel:description:CreateFleet' :: CreateFleet -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateFleet
s@CreateFleet' {} Maybe Text
a -> CreateFleet
s {$sel:description:CreateFleet' :: Maybe Text
description = Maybe Text
a} :: CreateFleet)

-- | Metadata that can be used to manage the fleet.
createFleet_tags :: Lens.Lens' CreateFleet (Prelude.Maybe [Tag])
createFleet_tags :: Lens' CreateFleet (Maybe [Tag])
createFleet_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateFleet' :: CreateFleet -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateFleet
s@CreateFleet' {} Maybe [Tag]
a -> CreateFleet
s {$sel:tags:CreateFleet' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateFleet) 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 fleet to create.
createFleet_fleetId :: Lens.Lens' CreateFleet Prelude.Text
createFleet_fleetId :: Lens' CreateFleet Text
createFleet_fleetId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Text
fleetId :: Text
$sel:fleetId:CreateFleet' :: CreateFleet -> Text
fleetId} -> Text
fleetId) (\s :: CreateFleet
s@CreateFleet' {} Text
a -> CreateFleet
s {$sel:fleetId:CreateFleet' :: Text
fleetId = Text
a} :: CreateFleet)

-- | The Amazon Resource Name (ARN) of a signal catalog.
createFleet_signalCatalogArn :: Lens.Lens' CreateFleet Prelude.Text
createFleet_signalCatalogArn :: Lens' CreateFleet Text
createFleet_signalCatalogArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Text
signalCatalogArn :: Text
$sel:signalCatalogArn:CreateFleet' :: CreateFleet -> Text
signalCatalogArn} -> Text
signalCatalogArn) (\s :: CreateFleet
s@CreateFleet' {} Text
a -> CreateFleet
s {$sel:signalCatalogArn:CreateFleet' :: Text
signalCatalogArn = Text
a} :: CreateFleet)

instance Core.AWSRequest CreateFleet where
  type AWSResponse CreateFleet = CreateFleetResponse
  request :: (Service -> Service) -> CreateFleet -> Request CreateFleet
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 CreateFleet
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateFleet)))
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 -> CreateFleetResponse
CreateFleetResponse'
            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
"id")
            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 CreateFleet where
  hashWithSalt :: Int -> CreateFleet -> Int
hashWithSalt Int
_salt CreateFleet' {Maybe [Tag]
Maybe Text
Text
signalCatalogArn :: Text
fleetId :: Text
tags :: Maybe [Tag]
description :: Maybe Text
$sel:signalCatalogArn:CreateFleet' :: CreateFleet -> Text
$sel:fleetId:CreateFleet' :: CreateFleet -> Text
$sel:tags:CreateFleet' :: CreateFleet -> Maybe [Tag]
$sel:description:CreateFleet' :: CreateFleet -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
fleetId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
signalCatalogArn

instance Prelude.NFData CreateFleet where
  rnf :: CreateFleet -> ()
rnf CreateFleet' {Maybe [Tag]
Maybe Text
Text
signalCatalogArn :: Text
fleetId :: Text
tags :: Maybe [Tag]
description :: Maybe Text
$sel:signalCatalogArn:CreateFleet' :: CreateFleet -> Text
$sel:fleetId:CreateFleet' :: CreateFleet -> Text
$sel:tags:CreateFleet' :: CreateFleet -> Maybe [Tag]
$sel:description:CreateFleet' :: CreateFleet -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      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
fleetId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
signalCatalogArn

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

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

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

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

-- |
-- Create a value of 'CreateFleetResponse' 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', 'createFleetResponse_httpStatus' - The response's http status code.
--
-- 'id', 'createFleetResponse_id' - The ID of the created fleet.
--
-- 'arn', 'createFleetResponse_arn' - The ARN of the created fleet.
newCreateFleetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'id'
  Prelude.Text ->
  -- | 'arn'
  Prelude.Text ->
  CreateFleetResponse
newCreateFleetResponse :: Int -> Text -> Text -> CreateFleetResponse
newCreateFleetResponse Int
pHttpStatus_ Text
pId_ Text
pArn_ =
  CreateFleetResponse'
    { $sel:httpStatus:CreateFleetResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:id:CreateFleetResponse' :: Text
id = Text
pId_,
      $sel:arn:CreateFleetResponse' :: Text
arn = Text
pArn_
    }

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

-- | The ID of the created fleet.
createFleetResponse_id :: Lens.Lens' CreateFleetResponse Prelude.Text
createFleetResponse_id :: Lens' CreateFleetResponse Text
createFleetResponse_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleetResponse' {Text
id :: Text
$sel:id:CreateFleetResponse' :: CreateFleetResponse -> Text
id} -> Text
id) (\s :: CreateFleetResponse
s@CreateFleetResponse' {} Text
a -> CreateFleetResponse
s {$sel:id:CreateFleetResponse' :: Text
id = Text
a} :: CreateFleetResponse)

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

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