{-# 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.IotTwinMaker.CreateScene
-- 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 scene.
module Amazonka.IotTwinMaker.CreateScene
  ( -- * Creating a Request
    CreateScene (..),
    newCreateScene,

    -- * Request Lenses
    createScene_capabilities,
    createScene_description,
    createScene_tags,
    createScene_workspaceId,
    createScene_sceneId,
    createScene_contentLocation,

    -- * Destructuring the Response
    CreateSceneResponse (..),
    newCreateSceneResponse,

    -- * Response Lenses
    createSceneResponse_httpStatus,
    createSceneResponse_arn,
    createSceneResponse_creationDateTime,
  )
where

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

-- | /See:/ 'newCreateScene' smart constructor.
data CreateScene = CreateScene'
  { -- | A list of capabilities that the scene uses to render itself.
    CreateScene -> Maybe [Text]
capabilities :: Prelude.Maybe [Prelude.Text],
    -- | The description for this scene.
    CreateScene -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Metadata that you can use to manage the scene.
    CreateScene -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The ID of the workspace that contains the scene.
    CreateScene -> Text
workspaceId :: Prelude.Text,
    -- | The ID of the scene.
    CreateScene -> Text
sceneId :: Prelude.Text,
    -- | The relative path that specifies the location of the content definition
    -- file.
    CreateScene -> Text
contentLocation :: Prelude.Text
  }
  deriving (CreateScene -> CreateScene -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateScene -> CreateScene -> Bool
$c/= :: CreateScene -> CreateScene -> Bool
== :: CreateScene -> CreateScene -> Bool
$c== :: CreateScene -> CreateScene -> Bool
Prelude.Eq, ReadPrec [CreateScene]
ReadPrec CreateScene
Int -> ReadS CreateScene
ReadS [CreateScene]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateScene]
$creadListPrec :: ReadPrec [CreateScene]
readPrec :: ReadPrec CreateScene
$creadPrec :: ReadPrec CreateScene
readList :: ReadS [CreateScene]
$creadList :: ReadS [CreateScene]
readsPrec :: Int -> ReadS CreateScene
$creadsPrec :: Int -> ReadS CreateScene
Prelude.Read, Int -> CreateScene -> ShowS
[CreateScene] -> ShowS
CreateScene -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateScene] -> ShowS
$cshowList :: [CreateScene] -> ShowS
show :: CreateScene -> String
$cshow :: CreateScene -> String
showsPrec :: Int -> CreateScene -> ShowS
$cshowsPrec :: Int -> CreateScene -> ShowS
Prelude.Show, forall x. Rep CreateScene x -> CreateScene
forall x. CreateScene -> Rep CreateScene x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateScene x -> CreateScene
$cfrom :: forall x. CreateScene -> Rep CreateScene x
Prelude.Generic)

-- |
-- Create a value of 'CreateScene' 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:
--
-- 'capabilities', 'createScene_capabilities' - A list of capabilities that the scene uses to render itself.
--
-- 'description', 'createScene_description' - The description for this scene.
--
-- 'tags', 'createScene_tags' - Metadata that you can use to manage the scene.
--
-- 'workspaceId', 'createScene_workspaceId' - The ID of the workspace that contains the scene.
--
-- 'sceneId', 'createScene_sceneId' - The ID of the scene.
--
-- 'contentLocation', 'createScene_contentLocation' - The relative path that specifies the location of the content definition
-- file.
newCreateScene ::
  -- | 'workspaceId'
  Prelude.Text ->
  -- | 'sceneId'
  Prelude.Text ->
  -- | 'contentLocation'
  Prelude.Text ->
  CreateScene
newCreateScene :: Text -> Text -> Text -> CreateScene
newCreateScene
  Text
pWorkspaceId_
  Text
pSceneId_
  Text
pContentLocation_ =
    CreateScene'
      { $sel:capabilities:CreateScene' :: Maybe [Text]
capabilities = forall a. Maybe a
Prelude.Nothing,
        $sel:description:CreateScene' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateScene' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:workspaceId:CreateScene' :: Text
workspaceId = Text
pWorkspaceId_,
        $sel:sceneId:CreateScene' :: Text
sceneId = Text
pSceneId_,
        $sel:contentLocation:CreateScene' :: Text
contentLocation = Text
pContentLocation_
      }

-- | A list of capabilities that the scene uses to render itself.
createScene_capabilities :: Lens.Lens' CreateScene (Prelude.Maybe [Prelude.Text])
createScene_capabilities :: Lens' CreateScene (Maybe [Text])
createScene_capabilities = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScene' {Maybe [Text]
capabilities :: Maybe [Text]
$sel:capabilities:CreateScene' :: CreateScene -> Maybe [Text]
capabilities} -> Maybe [Text]
capabilities) (\s :: CreateScene
s@CreateScene' {} Maybe [Text]
a -> CreateScene
s {$sel:capabilities:CreateScene' :: Maybe [Text]
capabilities = Maybe [Text]
a} :: CreateScene) 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 description for this scene.
createScene_description :: Lens.Lens' CreateScene (Prelude.Maybe Prelude.Text)
createScene_description :: Lens' CreateScene (Maybe Text)
createScene_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScene' {Maybe Text
description :: Maybe Text
$sel:description:CreateScene' :: CreateScene -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateScene
s@CreateScene' {} Maybe Text
a -> CreateScene
s {$sel:description:CreateScene' :: Maybe Text
description = Maybe Text
a} :: CreateScene)

-- | Metadata that you can use to manage the scene.
createScene_tags :: Lens.Lens' CreateScene (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createScene_tags :: Lens' CreateScene (Maybe (HashMap Text Text))
createScene_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScene' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateScene' :: CreateScene -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateScene
s@CreateScene' {} Maybe (HashMap Text Text)
a -> CreateScene
s {$sel:tags:CreateScene' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateScene) 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 ID of the workspace that contains the scene.
createScene_workspaceId :: Lens.Lens' CreateScene Prelude.Text
createScene_workspaceId :: Lens' CreateScene Text
createScene_workspaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScene' {Text
workspaceId :: Text
$sel:workspaceId:CreateScene' :: CreateScene -> Text
workspaceId} -> Text
workspaceId) (\s :: CreateScene
s@CreateScene' {} Text
a -> CreateScene
s {$sel:workspaceId:CreateScene' :: Text
workspaceId = Text
a} :: CreateScene)

-- | The ID of the scene.
createScene_sceneId :: Lens.Lens' CreateScene Prelude.Text
createScene_sceneId :: Lens' CreateScene Text
createScene_sceneId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScene' {Text
sceneId :: Text
$sel:sceneId:CreateScene' :: CreateScene -> Text
sceneId} -> Text
sceneId) (\s :: CreateScene
s@CreateScene' {} Text
a -> CreateScene
s {$sel:sceneId:CreateScene' :: Text
sceneId = Text
a} :: CreateScene)

-- | The relative path that specifies the location of the content definition
-- file.
createScene_contentLocation :: Lens.Lens' CreateScene Prelude.Text
createScene_contentLocation :: Lens' CreateScene Text
createScene_contentLocation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScene' {Text
contentLocation :: Text
$sel:contentLocation:CreateScene' :: CreateScene -> Text
contentLocation} -> Text
contentLocation) (\s :: CreateScene
s@CreateScene' {} Text
a -> CreateScene
s {$sel:contentLocation:CreateScene' :: Text
contentLocation = Text
a} :: CreateScene)

instance Core.AWSRequest CreateScene where
  type AWSResponse CreateScene = CreateSceneResponse
  request :: (Service -> Service) -> CreateScene -> Request CreateScene
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 CreateScene
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateScene)))
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 -> POSIX -> CreateSceneResponse
CreateSceneResponse'
            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
"creationDateTime")
      )

instance Prelude.Hashable CreateScene where
  hashWithSalt :: Int -> CreateScene -> Int
hashWithSalt Int
_salt CreateScene' {Maybe [Text]
Maybe Text
Maybe (HashMap Text Text)
Text
contentLocation :: Text
sceneId :: Text
workspaceId :: Text
tags :: Maybe (HashMap Text Text)
description :: Maybe Text
capabilities :: Maybe [Text]
$sel:contentLocation:CreateScene' :: CreateScene -> Text
$sel:sceneId:CreateScene' :: CreateScene -> Text
$sel:workspaceId:CreateScene' :: CreateScene -> Text
$sel:tags:CreateScene' :: CreateScene -> Maybe (HashMap Text Text)
$sel:description:CreateScene' :: CreateScene -> Maybe Text
$sel:capabilities:CreateScene' :: CreateScene -> Maybe [Text]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
capabilities
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
workspaceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
sceneId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
contentLocation

instance Prelude.NFData CreateScene where
  rnf :: CreateScene -> ()
rnf CreateScene' {Maybe [Text]
Maybe Text
Maybe (HashMap Text Text)
Text
contentLocation :: Text
sceneId :: Text
workspaceId :: Text
tags :: Maybe (HashMap Text Text)
description :: Maybe Text
capabilities :: Maybe [Text]
$sel:contentLocation:CreateScene' :: CreateScene -> Text
$sel:sceneId:CreateScene' :: CreateScene -> Text
$sel:workspaceId:CreateScene' :: CreateScene -> Text
$sel:tags:CreateScene' :: CreateScene -> Maybe (HashMap Text Text)
$sel:description:CreateScene' :: CreateScene -> Maybe Text
$sel:capabilities:CreateScene' :: CreateScene -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
capabilities
      seq :: forall a b. a -> b -> b
`Prelude.seq` 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 (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
workspaceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
sceneId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
contentLocation

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

instance Data.ToPath CreateScene where
  toPath :: CreateScene -> ByteString
toPath CreateScene' {Maybe [Text]
Maybe Text
Maybe (HashMap Text Text)
Text
contentLocation :: Text
sceneId :: Text
workspaceId :: Text
tags :: Maybe (HashMap Text Text)
description :: Maybe Text
capabilities :: Maybe [Text]
$sel:contentLocation:CreateScene' :: CreateScene -> Text
$sel:sceneId:CreateScene' :: CreateScene -> Text
$sel:workspaceId:CreateScene' :: CreateScene -> Text
$sel:tags:CreateScene' :: CreateScene -> Maybe (HashMap Text Text)
$sel:description:CreateScene' :: CreateScene -> Maybe Text
$sel:capabilities:CreateScene' :: CreateScene -> Maybe [Text]
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/workspaces/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
workspaceId, ByteString
"/scenes"]

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

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

-- |
-- Create a value of 'CreateSceneResponse' 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', 'createSceneResponse_httpStatus' - The response's http status code.
--
-- 'arn', 'createSceneResponse_arn' - The ARN of the scene.
--
-- 'creationDateTime', 'createSceneResponse_creationDateTime' - The date and time when the scene was created.
newCreateSceneResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'arn'
  Prelude.Text ->
  -- | 'creationDateTime'
  Prelude.UTCTime ->
  CreateSceneResponse
newCreateSceneResponse :: Int -> Text -> UTCTime -> CreateSceneResponse
newCreateSceneResponse
  Int
pHttpStatus_
  Text
pArn_
  UTCTime
pCreationDateTime_ =
    CreateSceneResponse'
      { $sel:httpStatus:CreateSceneResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:arn:CreateSceneResponse' :: Text
arn = Text
pArn_,
        $sel:creationDateTime:CreateSceneResponse' :: POSIX
creationDateTime =
          forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pCreationDateTime_
      }

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

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

-- | The date and time when the scene was created.
createSceneResponse_creationDateTime :: Lens.Lens' CreateSceneResponse Prelude.UTCTime
createSceneResponse_creationDateTime :: Lens' CreateSceneResponse UTCTime
createSceneResponse_creationDateTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSceneResponse' {POSIX
creationDateTime :: POSIX
$sel:creationDateTime:CreateSceneResponse' :: CreateSceneResponse -> POSIX
creationDateTime} -> POSIX
creationDateTime) (\s :: CreateSceneResponse
s@CreateSceneResponse' {} POSIX
a -> CreateSceneResponse
s {$sel:creationDateTime:CreateSceneResponse' :: POSIX
creationDateTime = POSIX
a} :: CreateSceneResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

instance Prelude.NFData CreateSceneResponse where
  rnf :: CreateSceneResponse -> ()
rnf CreateSceneResponse' {Int
Text
POSIX
creationDateTime :: POSIX
arn :: Text
httpStatus :: Int
$sel:creationDateTime:CreateSceneResponse' :: CreateSceneResponse -> POSIX
$sel:arn:CreateSceneResponse' :: CreateSceneResponse -> Text
$sel:httpStatus:CreateSceneResponse' :: CreateSceneResponse -> 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 POSIX
creationDateTime