{-# 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.IoTRoboRunner.CreateWorker
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Grants permission to create a worker
module Amazonka.IoTRoboRunner.CreateWorker
  ( -- * Creating a Request
    CreateWorker (..),
    newCreateWorker,

    -- * Request Lenses
    createWorker_additionalFixedProperties,
    createWorker_additionalTransientProperties,
    createWorker_clientToken,
    createWorker_orientation,
    createWorker_position,
    createWorker_vendorProperties,
    createWorker_name,
    createWorker_fleet,

    -- * Destructuring the Response
    CreateWorkerResponse (..),
    newCreateWorkerResponse,

    -- * Response Lenses
    createWorkerResponse_httpStatus,
    createWorkerResponse_arn,
    createWorkerResponse_id,
    createWorkerResponse_createdAt,
    createWorkerResponse_updatedAt,
    createWorkerResponse_site,
  )
where

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

-- | /See:/ 'newCreateWorker' smart constructor.
data CreateWorker = CreateWorker'
  { CreateWorker -> Maybe Text
additionalFixedProperties :: Prelude.Maybe Prelude.Text,
    CreateWorker -> Maybe Text
additionalTransientProperties :: Prelude.Maybe Prelude.Text,
    CreateWorker -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    CreateWorker -> Maybe Orientation
orientation :: Prelude.Maybe Orientation,
    CreateWorker -> Maybe PositionCoordinates
position :: Prelude.Maybe PositionCoordinates,
    CreateWorker -> Maybe VendorProperties
vendorProperties :: Prelude.Maybe VendorProperties,
    CreateWorker -> Text
name :: Prelude.Text,
    CreateWorker -> Text
fleet :: Prelude.Text
  }
  deriving (CreateWorker -> CreateWorker -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateWorker -> CreateWorker -> Bool
$c/= :: CreateWorker -> CreateWorker -> Bool
== :: CreateWorker -> CreateWorker -> Bool
$c== :: CreateWorker -> CreateWorker -> Bool
Prelude.Eq, ReadPrec [CreateWorker]
ReadPrec CreateWorker
Int -> ReadS CreateWorker
ReadS [CreateWorker]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateWorker]
$creadListPrec :: ReadPrec [CreateWorker]
readPrec :: ReadPrec CreateWorker
$creadPrec :: ReadPrec CreateWorker
readList :: ReadS [CreateWorker]
$creadList :: ReadS [CreateWorker]
readsPrec :: Int -> ReadS CreateWorker
$creadsPrec :: Int -> ReadS CreateWorker
Prelude.Read, Int -> CreateWorker -> ShowS
[CreateWorker] -> ShowS
CreateWorker -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateWorker] -> ShowS
$cshowList :: [CreateWorker] -> ShowS
show :: CreateWorker -> String
$cshow :: CreateWorker -> String
showsPrec :: Int -> CreateWorker -> ShowS
$cshowsPrec :: Int -> CreateWorker -> ShowS
Prelude.Show, forall x. Rep CreateWorker x -> CreateWorker
forall x. CreateWorker -> Rep CreateWorker x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateWorker x -> CreateWorker
$cfrom :: forall x. CreateWorker -> Rep CreateWorker x
Prelude.Generic)

-- |
-- Create a value of 'CreateWorker' 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:
--
-- 'additionalFixedProperties', 'createWorker_additionalFixedProperties' - Undocumented member.
--
-- 'additionalTransientProperties', 'createWorker_additionalTransientProperties' - Undocumented member.
--
-- 'clientToken', 'createWorker_clientToken' - Undocumented member.
--
-- 'orientation', 'createWorker_orientation' - Undocumented member.
--
-- 'position', 'createWorker_position' - Undocumented member.
--
-- 'vendorProperties', 'createWorker_vendorProperties' - Undocumented member.
--
-- 'name', 'createWorker_name' - Undocumented member.
--
-- 'fleet', 'createWorker_fleet' - Undocumented member.
newCreateWorker ::
  -- | 'name'
  Prelude.Text ->
  -- | 'fleet'
  Prelude.Text ->
  CreateWorker
newCreateWorker :: Text -> Text -> CreateWorker
newCreateWorker Text
pName_ Text
pFleet_ =
  CreateWorker'
    { $sel:additionalFixedProperties:CreateWorker' :: Maybe Text
additionalFixedProperties =
        forall a. Maybe a
Prelude.Nothing,
      $sel:additionalTransientProperties:CreateWorker' :: Maybe Text
additionalTransientProperties = forall a. Maybe a
Prelude.Nothing,
      $sel:clientToken:CreateWorker' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
      $sel:orientation:CreateWorker' :: Maybe Orientation
orientation = forall a. Maybe a
Prelude.Nothing,
      $sel:position:CreateWorker' :: Maybe PositionCoordinates
position = forall a. Maybe a
Prelude.Nothing,
      $sel:vendorProperties:CreateWorker' :: Maybe VendorProperties
vendorProperties = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateWorker' :: Text
name = Text
pName_,
      $sel:fleet:CreateWorker' :: Text
fleet = Text
pFleet_
    }

-- | Undocumented member.
createWorker_additionalFixedProperties :: Lens.Lens' CreateWorker (Prelude.Maybe Prelude.Text)
createWorker_additionalFixedProperties :: Lens' CreateWorker (Maybe Text)
createWorker_additionalFixedProperties = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorker' {Maybe Text
additionalFixedProperties :: Maybe Text
$sel:additionalFixedProperties:CreateWorker' :: CreateWorker -> Maybe Text
additionalFixedProperties} -> Maybe Text
additionalFixedProperties) (\s :: CreateWorker
s@CreateWorker' {} Maybe Text
a -> CreateWorker
s {$sel:additionalFixedProperties:CreateWorker' :: Maybe Text
additionalFixedProperties = Maybe Text
a} :: CreateWorker)

-- | Undocumented member.
createWorker_additionalTransientProperties :: Lens.Lens' CreateWorker (Prelude.Maybe Prelude.Text)
createWorker_additionalTransientProperties :: Lens' CreateWorker (Maybe Text)
createWorker_additionalTransientProperties = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorker' {Maybe Text
additionalTransientProperties :: Maybe Text
$sel:additionalTransientProperties:CreateWorker' :: CreateWorker -> Maybe Text
additionalTransientProperties} -> Maybe Text
additionalTransientProperties) (\s :: CreateWorker
s@CreateWorker' {} Maybe Text
a -> CreateWorker
s {$sel:additionalTransientProperties:CreateWorker' :: Maybe Text
additionalTransientProperties = Maybe Text
a} :: CreateWorker)

-- | Undocumented member.
createWorker_clientToken :: Lens.Lens' CreateWorker (Prelude.Maybe Prelude.Text)
createWorker_clientToken :: Lens' CreateWorker (Maybe Text)
createWorker_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorker' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateWorker' :: CreateWorker -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateWorker
s@CreateWorker' {} Maybe Text
a -> CreateWorker
s {$sel:clientToken:CreateWorker' :: Maybe Text
clientToken = Maybe Text
a} :: CreateWorker)

-- | Undocumented member.
createWorker_orientation :: Lens.Lens' CreateWorker (Prelude.Maybe Orientation)
createWorker_orientation :: Lens' CreateWorker (Maybe Orientation)
createWorker_orientation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorker' {Maybe Orientation
orientation :: Maybe Orientation
$sel:orientation:CreateWorker' :: CreateWorker -> Maybe Orientation
orientation} -> Maybe Orientation
orientation) (\s :: CreateWorker
s@CreateWorker' {} Maybe Orientation
a -> CreateWorker
s {$sel:orientation:CreateWorker' :: Maybe Orientation
orientation = Maybe Orientation
a} :: CreateWorker)

-- | Undocumented member.
createWorker_position :: Lens.Lens' CreateWorker (Prelude.Maybe PositionCoordinates)
createWorker_position :: Lens' CreateWorker (Maybe PositionCoordinates)
createWorker_position = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorker' {Maybe PositionCoordinates
position :: Maybe PositionCoordinates
$sel:position:CreateWorker' :: CreateWorker -> Maybe PositionCoordinates
position} -> Maybe PositionCoordinates
position) (\s :: CreateWorker
s@CreateWorker' {} Maybe PositionCoordinates
a -> CreateWorker
s {$sel:position:CreateWorker' :: Maybe PositionCoordinates
position = Maybe PositionCoordinates
a} :: CreateWorker)

-- | Undocumented member.
createWorker_vendorProperties :: Lens.Lens' CreateWorker (Prelude.Maybe VendorProperties)
createWorker_vendorProperties :: Lens' CreateWorker (Maybe VendorProperties)
createWorker_vendorProperties = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorker' {Maybe VendorProperties
vendorProperties :: Maybe VendorProperties
$sel:vendorProperties:CreateWorker' :: CreateWorker -> Maybe VendorProperties
vendorProperties} -> Maybe VendorProperties
vendorProperties) (\s :: CreateWorker
s@CreateWorker' {} Maybe VendorProperties
a -> CreateWorker
s {$sel:vendorProperties:CreateWorker' :: Maybe VendorProperties
vendorProperties = Maybe VendorProperties
a} :: CreateWorker)

-- | Undocumented member.
createWorker_name :: Lens.Lens' CreateWorker Prelude.Text
createWorker_name :: Lens' CreateWorker Text
createWorker_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorker' {Text
name :: Text
$sel:name:CreateWorker' :: CreateWorker -> Text
name} -> Text
name) (\s :: CreateWorker
s@CreateWorker' {} Text
a -> CreateWorker
s {$sel:name:CreateWorker' :: Text
name = Text
a} :: CreateWorker)

-- | Undocumented member.
createWorker_fleet :: Lens.Lens' CreateWorker Prelude.Text
createWorker_fleet :: Lens' CreateWorker Text
createWorker_fleet = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorker' {Text
fleet :: Text
$sel:fleet:CreateWorker' :: CreateWorker -> Text
fleet} -> Text
fleet) (\s :: CreateWorker
s@CreateWorker' {} Text
a -> CreateWorker
s {$sel:fleet:CreateWorker' :: Text
fleet = Text
a} :: CreateWorker)

instance Core.AWSRequest CreateWorker where
  type AWSResponse CreateWorker = CreateWorkerResponse
  request :: (Service -> Service) -> CreateWorker -> Request CreateWorker
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 CreateWorker
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateWorker)))
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 -> POSIX -> POSIX -> Text -> CreateWorkerResponse
CreateWorkerResponse'
            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
"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 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
"createdAt")
            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
"updatedAt")
            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
"site")
      )

instance Prelude.Hashable CreateWorker where
  hashWithSalt :: Int -> CreateWorker -> Int
hashWithSalt Int
_salt CreateWorker' {Maybe Text
Maybe Orientation
Maybe PositionCoordinates
Maybe VendorProperties
Text
fleet :: Text
name :: Text
vendorProperties :: Maybe VendorProperties
position :: Maybe PositionCoordinates
orientation :: Maybe Orientation
clientToken :: Maybe Text
additionalTransientProperties :: Maybe Text
additionalFixedProperties :: Maybe Text
$sel:fleet:CreateWorker' :: CreateWorker -> Text
$sel:name:CreateWorker' :: CreateWorker -> Text
$sel:vendorProperties:CreateWorker' :: CreateWorker -> Maybe VendorProperties
$sel:position:CreateWorker' :: CreateWorker -> Maybe PositionCoordinates
$sel:orientation:CreateWorker' :: CreateWorker -> Maybe Orientation
$sel:clientToken:CreateWorker' :: CreateWorker -> Maybe Text
$sel:additionalTransientProperties:CreateWorker' :: CreateWorker -> Maybe Text
$sel:additionalFixedProperties:CreateWorker' :: CreateWorker -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
additionalFixedProperties
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
additionalTransientProperties
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Orientation
orientation
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PositionCoordinates
position
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VendorProperties
vendorProperties
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
fleet

instance Prelude.NFData CreateWorker where
  rnf :: CreateWorker -> ()
rnf CreateWorker' {Maybe Text
Maybe Orientation
Maybe PositionCoordinates
Maybe VendorProperties
Text
fleet :: Text
name :: Text
vendorProperties :: Maybe VendorProperties
position :: Maybe PositionCoordinates
orientation :: Maybe Orientation
clientToken :: Maybe Text
additionalTransientProperties :: Maybe Text
additionalFixedProperties :: Maybe Text
$sel:fleet:CreateWorker' :: CreateWorker -> Text
$sel:name:CreateWorker' :: CreateWorker -> Text
$sel:vendorProperties:CreateWorker' :: CreateWorker -> Maybe VendorProperties
$sel:position:CreateWorker' :: CreateWorker -> Maybe PositionCoordinates
$sel:orientation:CreateWorker' :: CreateWorker -> Maybe Orientation
$sel:clientToken:CreateWorker' :: CreateWorker -> Maybe Text
$sel:additionalTransientProperties:CreateWorker' :: CreateWorker -> Maybe Text
$sel:additionalFixedProperties:CreateWorker' :: CreateWorker -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
additionalFixedProperties
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
additionalTransientProperties
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Orientation
orientation
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PositionCoordinates
position
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe VendorProperties
vendorProperties
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
fleet

instance Data.ToHeaders CreateWorker where
  toHeaders :: CreateWorker -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateWorker where
  toJSON :: CreateWorker -> Value
toJSON CreateWorker' {Maybe Text
Maybe Orientation
Maybe PositionCoordinates
Maybe VendorProperties
Text
fleet :: Text
name :: Text
vendorProperties :: Maybe VendorProperties
position :: Maybe PositionCoordinates
orientation :: Maybe Orientation
clientToken :: Maybe Text
additionalTransientProperties :: Maybe Text
additionalFixedProperties :: Maybe Text
$sel:fleet:CreateWorker' :: CreateWorker -> Text
$sel:name:CreateWorker' :: CreateWorker -> Text
$sel:vendorProperties:CreateWorker' :: CreateWorker -> Maybe VendorProperties
$sel:position:CreateWorker' :: CreateWorker -> Maybe PositionCoordinates
$sel:orientation:CreateWorker' :: CreateWorker -> Maybe Orientation
$sel:clientToken:CreateWorker' :: CreateWorker -> Maybe Text
$sel:additionalTransientProperties:CreateWorker' :: CreateWorker -> Maybe Text
$sel:additionalFixedProperties:CreateWorker' :: CreateWorker -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"additionalFixedProperties" 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
additionalFixedProperties,
            (Key
"additionalTransientProperties" 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
additionalTransientProperties,
            (Key
"clientToken" 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
clientToken,
            (Key
"orientation" 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 Orientation
orientation,
            (Key
"position" 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 PositionCoordinates
position,
            (Key
"vendorProperties" 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 VendorProperties
vendorProperties,
            forall a. a -> Maybe a
Prelude.Just (Key
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just (Key
"fleet" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
fleet)
          ]
      )

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

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

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

-- |
-- Create a value of 'CreateWorkerResponse' 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', 'createWorkerResponse_httpStatus' - The response's http status code.
--
-- 'arn', 'createWorkerResponse_arn' - Undocumented member.
--
-- 'id', 'createWorkerResponse_id' - Undocumented member.
--
-- 'createdAt', 'createWorkerResponse_createdAt' - Undocumented member.
--
-- 'updatedAt', 'createWorkerResponse_updatedAt' - Undocumented member.
--
-- 'site', 'createWorkerResponse_site' - Undocumented member.
newCreateWorkerResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'arn'
  Prelude.Text ->
  -- | 'id'
  Prelude.Text ->
  -- | 'createdAt'
  Prelude.UTCTime ->
  -- | 'updatedAt'
  Prelude.UTCTime ->
  -- | 'site'
  Prelude.Text ->
  CreateWorkerResponse
newCreateWorkerResponse :: Int
-> Text
-> Text
-> UTCTime
-> UTCTime
-> Text
-> CreateWorkerResponse
newCreateWorkerResponse
  Int
pHttpStatus_
  Text
pArn_
  Text
pId_
  UTCTime
pCreatedAt_
  UTCTime
pUpdatedAt_
  Text
pSite_ =
    CreateWorkerResponse'
      { $sel:httpStatus:CreateWorkerResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:arn:CreateWorkerResponse' :: Text
arn = Text
pArn_,
        $sel:id:CreateWorkerResponse' :: Text
id = Text
pId_,
        $sel:createdAt:CreateWorkerResponse' :: POSIX
createdAt = forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pCreatedAt_,
        $sel:updatedAt:CreateWorkerResponse' :: POSIX
updatedAt = forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pUpdatedAt_,
        $sel:site:CreateWorkerResponse' :: Text
site = Text
pSite_
      }

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

-- | Undocumented member.
createWorkerResponse_arn :: Lens.Lens' CreateWorkerResponse Prelude.Text
createWorkerResponse_arn :: Lens' CreateWorkerResponse Text
createWorkerResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkerResponse' {Text
arn :: Text
$sel:arn:CreateWorkerResponse' :: CreateWorkerResponse -> Text
arn} -> Text
arn) (\s :: CreateWorkerResponse
s@CreateWorkerResponse' {} Text
a -> CreateWorkerResponse
s {$sel:arn:CreateWorkerResponse' :: Text
arn = Text
a} :: CreateWorkerResponse)

-- | Undocumented member.
createWorkerResponse_id :: Lens.Lens' CreateWorkerResponse Prelude.Text
createWorkerResponse_id :: Lens' CreateWorkerResponse Text
createWorkerResponse_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkerResponse' {Text
id :: Text
$sel:id:CreateWorkerResponse' :: CreateWorkerResponse -> Text
id} -> Text
id) (\s :: CreateWorkerResponse
s@CreateWorkerResponse' {} Text
a -> CreateWorkerResponse
s {$sel:id:CreateWorkerResponse' :: Text
id = Text
a} :: CreateWorkerResponse)

-- | Undocumented member.
createWorkerResponse_createdAt :: Lens.Lens' CreateWorkerResponse Prelude.UTCTime
createWorkerResponse_createdAt :: Lens' CreateWorkerResponse UTCTime
createWorkerResponse_createdAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkerResponse' {POSIX
createdAt :: POSIX
$sel:createdAt:CreateWorkerResponse' :: CreateWorkerResponse -> POSIX
createdAt} -> POSIX
createdAt) (\s :: CreateWorkerResponse
s@CreateWorkerResponse' {} POSIX
a -> CreateWorkerResponse
s {$sel:createdAt:CreateWorkerResponse' :: POSIX
createdAt = POSIX
a} :: CreateWorkerResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | Undocumented member.
createWorkerResponse_updatedAt :: Lens.Lens' CreateWorkerResponse Prelude.UTCTime
createWorkerResponse_updatedAt :: Lens' CreateWorkerResponse UTCTime
createWorkerResponse_updatedAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkerResponse' {POSIX
updatedAt :: POSIX
$sel:updatedAt:CreateWorkerResponse' :: CreateWorkerResponse -> POSIX
updatedAt} -> POSIX
updatedAt) (\s :: CreateWorkerResponse
s@CreateWorkerResponse' {} POSIX
a -> CreateWorkerResponse
s {$sel:updatedAt:CreateWorkerResponse' :: POSIX
updatedAt = POSIX
a} :: CreateWorkerResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | Undocumented member.
createWorkerResponse_site :: Lens.Lens' CreateWorkerResponse Prelude.Text
createWorkerResponse_site :: Lens' CreateWorkerResponse Text
createWorkerResponse_site = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkerResponse' {Text
site :: Text
$sel:site:CreateWorkerResponse' :: CreateWorkerResponse -> Text
site} -> Text
site) (\s :: CreateWorkerResponse
s@CreateWorkerResponse' {} Text
a -> CreateWorkerResponse
s {$sel:site:CreateWorkerResponse' :: Text
site = Text
a} :: CreateWorkerResponse)

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