{-# 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.WorkSpaces.CreateWorkspaceImage
-- 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 new WorkSpace image from an existing WorkSpace.
module Amazonka.WorkSpaces.CreateWorkspaceImage
  ( -- * Creating a Request
    CreateWorkspaceImage (..),
    newCreateWorkspaceImage,

    -- * Request Lenses
    createWorkspaceImage_tags,
    createWorkspaceImage_name,
    createWorkspaceImage_description,
    createWorkspaceImage_workspaceId,

    -- * Destructuring the Response
    CreateWorkspaceImageResponse (..),
    newCreateWorkspaceImageResponse,

    -- * Response Lenses
    createWorkspaceImageResponse_created,
    createWorkspaceImageResponse_description,
    createWorkspaceImageResponse_imageId,
    createWorkspaceImageResponse_name,
    createWorkspaceImageResponse_operatingSystem,
    createWorkspaceImageResponse_ownerAccountId,
    createWorkspaceImageResponse_requiredTenancy,
    createWorkspaceImageResponse_state,
    createWorkspaceImageResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateWorkspaceImage' smart constructor.
data CreateWorkspaceImage = CreateWorkspaceImage'
  { -- | The tags that you want to add to the new WorkSpace image. To add tags
    -- when you\'re creating the image, you must create an IAM policy that
    -- grants your IAM user permission to use @workspaces:CreateTags@.
    CreateWorkspaceImage -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the new WorkSpace image.
    CreateWorkspaceImage -> Text
name :: Prelude.Text,
    -- | The description of the new WorkSpace image.
    CreateWorkspaceImage -> Text
description :: Prelude.Text,
    -- | The identifier of the source WorkSpace
    CreateWorkspaceImage -> Text
workspaceId :: Prelude.Text
  }
  deriving (CreateWorkspaceImage -> CreateWorkspaceImage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateWorkspaceImage -> CreateWorkspaceImage -> Bool
$c/= :: CreateWorkspaceImage -> CreateWorkspaceImage -> Bool
== :: CreateWorkspaceImage -> CreateWorkspaceImage -> Bool
$c== :: CreateWorkspaceImage -> CreateWorkspaceImage -> Bool
Prelude.Eq, ReadPrec [CreateWorkspaceImage]
ReadPrec CreateWorkspaceImage
Int -> ReadS CreateWorkspaceImage
ReadS [CreateWorkspaceImage]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateWorkspaceImage]
$creadListPrec :: ReadPrec [CreateWorkspaceImage]
readPrec :: ReadPrec CreateWorkspaceImage
$creadPrec :: ReadPrec CreateWorkspaceImage
readList :: ReadS [CreateWorkspaceImage]
$creadList :: ReadS [CreateWorkspaceImage]
readsPrec :: Int -> ReadS CreateWorkspaceImage
$creadsPrec :: Int -> ReadS CreateWorkspaceImage
Prelude.Read, Int -> CreateWorkspaceImage -> ShowS
[CreateWorkspaceImage] -> ShowS
CreateWorkspaceImage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateWorkspaceImage] -> ShowS
$cshowList :: [CreateWorkspaceImage] -> ShowS
show :: CreateWorkspaceImage -> String
$cshow :: CreateWorkspaceImage -> String
showsPrec :: Int -> CreateWorkspaceImage -> ShowS
$cshowsPrec :: Int -> CreateWorkspaceImage -> ShowS
Prelude.Show, forall x. Rep CreateWorkspaceImage x -> CreateWorkspaceImage
forall x. CreateWorkspaceImage -> Rep CreateWorkspaceImage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateWorkspaceImage x -> CreateWorkspaceImage
$cfrom :: forall x. CreateWorkspaceImage -> Rep CreateWorkspaceImage x
Prelude.Generic)

-- |
-- Create a value of 'CreateWorkspaceImage' 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:
--
-- 'tags', 'createWorkspaceImage_tags' - The tags that you want to add to the new WorkSpace image. To add tags
-- when you\'re creating the image, you must create an IAM policy that
-- grants your IAM user permission to use @workspaces:CreateTags@.
--
-- 'name', 'createWorkspaceImage_name' - The name of the new WorkSpace image.
--
-- 'description', 'createWorkspaceImage_description' - The description of the new WorkSpace image.
--
-- 'workspaceId', 'createWorkspaceImage_workspaceId' - The identifier of the source WorkSpace
newCreateWorkspaceImage ::
  -- | 'name'
  Prelude.Text ->
  -- | 'description'
  Prelude.Text ->
  -- | 'workspaceId'
  Prelude.Text ->
  CreateWorkspaceImage
newCreateWorkspaceImage :: Text -> Text -> Text -> CreateWorkspaceImage
newCreateWorkspaceImage
  Text
pName_
  Text
pDescription_
  Text
pWorkspaceId_ =
    CreateWorkspaceImage'
      { $sel:tags:CreateWorkspaceImage' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:name:CreateWorkspaceImage' :: Text
name = Text
pName_,
        $sel:description:CreateWorkspaceImage' :: Text
description = Text
pDescription_,
        $sel:workspaceId:CreateWorkspaceImage' :: Text
workspaceId = Text
pWorkspaceId_
      }

-- | The tags that you want to add to the new WorkSpace image. To add tags
-- when you\'re creating the image, you must create an IAM policy that
-- grants your IAM user permission to use @workspaces:CreateTags@.
createWorkspaceImage_tags :: Lens.Lens' CreateWorkspaceImage (Prelude.Maybe [Tag])
createWorkspaceImage_tags :: Lens' CreateWorkspaceImage (Maybe [Tag])
createWorkspaceImage_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImage' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateWorkspaceImage' :: CreateWorkspaceImage -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateWorkspaceImage
s@CreateWorkspaceImage' {} Maybe [Tag]
a -> CreateWorkspaceImage
s {$sel:tags:CreateWorkspaceImage' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateWorkspaceImage) 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 name of the new WorkSpace image.
createWorkspaceImage_name :: Lens.Lens' CreateWorkspaceImage Prelude.Text
createWorkspaceImage_name :: Lens' CreateWorkspaceImage Text
createWorkspaceImage_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImage' {Text
name :: Text
$sel:name:CreateWorkspaceImage' :: CreateWorkspaceImage -> Text
name} -> Text
name) (\s :: CreateWorkspaceImage
s@CreateWorkspaceImage' {} Text
a -> CreateWorkspaceImage
s {$sel:name:CreateWorkspaceImage' :: Text
name = Text
a} :: CreateWorkspaceImage)

-- | The description of the new WorkSpace image.
createWorkspaceImage_description :: Lens.Lens' CreateWorkspaceImage Prelude.Text
createWorkspaceImage_description :: Lens' CreateWorkspaceImage Text
createWorkspaceImage_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImage' {Text
description :: Text
$sel:description:CreateWorkspaceImage' :: CreateWorkspaceImage -> Text
description} -> Text
description) (\s :: CreateWorkspaceImage
s@CreateWorkspaceImage' {} Text
a -> CreateWorkspaceImage
s {$sel:description:CreateWorkspaceImage' :: Text
description = Text
a} :: CreateWorkspaceImage)

-- | The identifier of the source WorkSpace
createWorkspaceImage_workspaceId :: Lens.Lens' CreateWorkspaceImage Prelude.Text
createWorkspaceImage_workspaceId :: Lens' CreateWorkspaceImage Text
createWorkspaceImage_workspaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImage' {Text
workspaceId :: Text
$sel:workspaceId:CreateWorkspaceImage' :: CreateWorkspaceImage -> Text
workspaceId} -> Text
workspaceId) (\s :: CreateWorkspaceImage
s@CreateWorkspaceImage' {} Text
a -> CreateWorkspaceImage
s {$sel:workspaceId:CreateWorkspaceImage' :: Text
workspaceId = Text
a} :: CreateWorkspaceImage)

instance Core.AWSRequest CreateWorkspaceImage where
  type
    AWSResponse CreateWorkspaceImage =
      CreateWorkspaceImageResponse
  request :: (Service -> Service)
-> CreateWorkspaceImage -> Request CreateWorkspaceImage
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 CreateWorkspaceImage
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateWorkspaceImage)))
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 POSIX
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe OperatingSystem
-> Maybe Text
-> Maybe WorkspaceImageRequiredTenancy
-> Maybe WorkspaceImageState
-> Int
-> CreateWorkspaceImageResponse
CreateWorkspaceImageResponse'
            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
"Created")
            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
"Description")
            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
"ImageId")
            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
"Name")
            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
"OperatingSystem")
            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
"OwnerAccountId")
            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
"RequiredTenancy")
            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
"State")
            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 CreateWorkspaceImage where
  hashWithSalt :: Int -> CreateWorkspaceImage -> Int
hashWithSalt Int
_salt CreateWorkspaceImage' {Maybe [Tag]
Text
workspaceId :: Text
description :: Text
name :: Text
tags :: Maybe [Tag]
$sel:workspaceId:CreateWorkspaceImage' :: CreateWorkspaceImage -> Text
$sel:description:CreateWorkspaceImage' :: CreateWorkspaceImage -> Text
$sel:name:CreateWorkspaceImage' :: CreateWorkspaceImage -> Text
$sel:tags:CreateWorkspaceImage' :: CreateWorkspaceImage -> Maybe [Tag]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
workspaceId

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

instance Data.ToHeaders CreateWorkspaceImage where
  toHeaders :: CreateWorkspaceImage -> 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
"WorkspacesService.CreateWorkspaceImage" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

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

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

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

-- | /See:/ 'newCreateWorkspaceImageResponse' smart constructor.
data CreateWorkspaceImageResponse = CreateWorkspaceImageResponse'
  { -- | The date when the image was created.
    CreateWorkspaceImageResponse -> Maybe POSIX
created :: Prelude.Maybe Data.POSIX,
    -- | The description of the image.
    CreateWorkspaceImageResponse -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The identifier of the new WorkSpace image.
    CreateWorkspaceImageResponse -> Maybe Text
imageId :: Prelude.Maybe Prelude.Text,
    -- | The name of the image.
    CreateWorkspaceImageResponse -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The operating system that the image is running.
    CreateWorkspaceImageResponse -> Maybe OperatingSystem
operatingSystem :: Prelude.Maybe OperatingSystem,
    -- | The identifier of the Amazon Web Services account that owns the image.
    CreateWorkspaceImageResponse -> Maybe Text
ownerAccountId :: Prelude.Maybe Prelude.Text,
    -- | Specifies whether the image is running on dedicated hardware. When Bring
    -- Your Own License (BYOL) is enabled, this value is set to DEDICATED. For
    -- more information, see
    -- <https://docs.aws.amazon.com/workspaces/latest/adminguide/byol-windows-images.htm Bring Your Own Windows Desktop Images.>.
    CreateWorkspaceImageResponse -> Maybe WorkspaceImageRequiredTenancy
requiredTenancy :: Prelude.Maybe WorkspaceImageRequiredTenancy,
    -- | The availability status of the image.
    CreateWorkspaceImageResponse -> Maybe WorkspaceImageState
state :: Prelude.Maybe WorkspaceImageState,
    -- | The response's http status code.
    CreateWorkspaceImageResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateWorkspaceImageResponse
-> CreateWorkspaceImageResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateWorkspaceImageResponse
-> CreateWorkspaceImageResponse -> Bool
$c/= :: CreateWorkspaceImageResponse
-> CreateWorkspaceImageResponse -> Bool
== :: CreateWorkspaceImageResponse
-> CreateWorkspaceImageResponse -> Bool
$c== :: CreateWorkspaceImageResponse
-> CreateWorkspaceImageResponse -> Bool
Prelude.Eq, ReadPrec [CreateWorkspaceImageResponse]
ReadPrec CreateWorkspaceImageResponse
Int -> ReadS CreateWorkspaceImageResponse
ReadS [CreateWorkspaceImageResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateWorkspaceImageResponse]
$creadListPrec :: ReadPrec [CreateWorkspaceImageResponse]
readPrec :: ReadPrec CreateWorkspaceImageResponse
$creadPrec :: ReadPrec CreateWorkspaceImageResponse
readList :: ReadS [CreateWorkspaceImageResponse]
$creadList :: ReadS [CreateWorkspaceImageResponse]
readsPrec :: Int -> ReadS CreateWorkspaceImageResponse
$creadsPrec :: Int -> ReadS CreateWorkspaceImageResponse
Prelude.Read, Int -> CreateWorkspaceImageResponse -> ShowS
[CreateWorkspaceImageResponse] -> ShowS
CreateWorkspaceImageResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateWorkspaceImageResponse] -> ShowS
$cshowList :: [CreateWorkspaceImageResponse] -> ShowS
show :: CreateWorkspaceImageResponse -> String
$cshow :: CreateWorkspaceImageResponse -> String
showsPrec :: Int -> CreateWorkspaceImageResponse -> ShowS
$cshowsPrec :: Int -> CreateWorkspaceImageResponse -> ShowS
Prelude.Show, forall x.
Rep CreateWorkspaceImageResponse x -> CreateWorkspaceImageResponse
forall x.
CreateWorkspaceImageResponse -> Rep CreateWorkspaceImageResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateWorkspaceImageResponse x -> CreateWorkspaceImageResponse
$cfrom :: forall x.
CreateWorkspaceImageResponse -> Rep CreateWorkspaceImageResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateWorkspaceImageResponse' 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:
--
-- 'created', 'createWorkspaceImageResponse_created' - The date when the image was created.
--
-- 'description', 'createWorkspaceImageResponse_description' - The description of the image.
--
-- 'imageId', 'createWorkspaceImageResponse_imageId' - The identifier of the new WorkSpace image.
--
-- 'name', 'createWorkspaceImageResponse_name' - The name of the image.
--
-- 'operatingSystem', 'createWorkspaceImageResponse_operatingSystem' - The operating system that the image is running.
--
-- 'ownerAccountId', 'createWorkspaceImageResponse_ownerAccountId' - The identifier of the Amazon Web Services account that owns the image.
--
-- 'requiredTenancy', 'createWorkspaceImageResponse_requiredTenancy' - Specifies whether the image is running on dedicated hardware. When Bring
-- Your Own License (BYOL) is enabled, this value is set to DEDICATED. For
-- more information, see
-- <https://docs.aws.amazon.com/workspaces/latest/adminguide/byol-windows-images.htm Bring Your Own Windows Desktop Images.>.
--
-- 'state', 'createWorkspaceImageResponse_state' - The availability status of the image.
--
-- 'httpStatus', 'createWorkspaceImageResponse_httpStatus' - The response's http status code.
newCreateWorkspaceImageResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateWorkspaceImageResponse
newCreateWorkspaceImageResponse :: Int -> CreateWorkspaceImageResponse
newCreateWorkspaceImageResponse Int
pHttpStatus_ =
  CreateWorkspaceImageResponse'
    { $sel:created:CreateWorkspaceImageResponse' :: Maybe POSIX
created =
        forall a. Maybe a
Prelude.Nothing,
      $sel:description:CreateWorkspaceImageResponse' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:imageId:CreateWorkspaceImageResponse' :: Maybe Text
imageId = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateWorkspaceImageResponse' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:operatingSystem:CreateWorkspaceImageResponse' :: Maybe OperatingSystem
operatingSystem = forall a. Maybe a
Prelude.Nothing,
      $sel:ownerAccountId:CreateWorkspaceImageResponse' :: Maybe Text
ownerAccountId = forall a. Maybe a
Prelude.Nothing,
      $sel:requiredTenancy:CreateWorkspaceImageResponse' :: Maybe WorkspaceImageRequiredTenancy
requiredTenancy = forall a. Maybe a
Prelude.Nothing,
      $sel:state:CreateWorkspaceImageResponse' :: Maybe WorkspaceImageState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateWorkspaceImageResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The date when the image was created.
createWorkspaceImageResponse_created :: Lens.Lens' CreateWorkspaceImageResponse (Prelude.Maybe Prelude.UTCTime)
createWorkspaceImageResponse_created :: Lens' CreateWorkspaceImageResponse (Maybe UTCTime)
createWorkspaceImageResponse_created = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImageResponse' {Maybe POSIX
created :: Maybe POSIX
$sel:created:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe POSIX
created} -> Maybe POSIX
created) (\s :: CreateWorkspaceImageResponse
s@CreateWorkspaceImageResponse' {} Maybe POSIX
a -> CreateWorkspaceImageResponse
s {$sel:created:CreateWorkspaceImageResponse' :: Maybe POSIX
created = Maybe POSIX
a} :: CreateWorkspaceImageResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The description of the image.
createWorkspaceImageResponse_description :: Lens.Lens' CreateWorkspaceImageResponse (Prelude.Maybe Prelude.Text)
createWorkspaceImageResponse_description :: Lens' CreateWorkspaceImageResponse (Maybe Text)
createWorkspaceImageResponse_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImageResponse' {Maybe Text
description :: Maybe Text
$sel:description:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateWorkspaceImageResponse
s@CreateWorkspaceImageResponse' {} Maybe Text
a -> CreateWorkspaceImageResponse
s {$sel:description:CreateWorkspaceImageResponse' :: Maybe Text
description = Maybe Text
a} :: CreateWorkspaceImageResponse)

-- | The identifier of the new WorkSpace image.
createWorkspaceImageResponse_imageId :: Lens.Lens' CreateWorkspaceImageResponse (Prelude.Maybe Prelude.Text)
createWorkspaceImageResponse_imageId :: Lens' CreateWorkspaceImageResponse (Maybe Text)
createWorkspaceImageResponse_imageId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImageResponse' {Maybe Text
imageId :: Maybe Text
$sel:imageId:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe Text
imageId} -> Maybe Text
imageId) (\s :: CreateWorkspaceImageResponse
s@CreateWorkspaceImageResponse' {} Maybe Text
a -> CreateWorkspaceImageResponse
s {$sel:imageId:CreateWorkspaceImageResponse' :: Maybe Text
imageId = Maybe Text
a} :: CreateWorkspaceImageResponse)

-- | The name of the image.
createWorkspaceImageResponse_name :: Lens.Lens' CreateWorkspaceImageResponse (Prelude.Maybe Prelude.Text)
createWorkspaceImageResponse_name :: Lens' CreateWorkspaceImageResponse (Maybe Text)
createWorkspaceImageResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImageResponse' {Maybe Text
name :: Maybe Text
$sel:name:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe Text
name} -> Maybe Text
name) (\s :: CreateWorkspaceImageResponse
s@CreateWorkspaceImageResponse' {} Maybe Text
a -> CreateWorkspaceImageResponse
s {$sel:name:CreateWorkspaceImageResponse' :: Maybe Text
name = Maybe Text
a} :: CreateWorkspaceImageResponse)

-- | The operating system that the image is running.
createWorkspaceImageResponse_operatingSystem :: Lens.Lens' CreateWorkspaceImageResponse (Prelude.Maybe OperatingSystem)
createWorkspaceImageResponse_operatingSystem :: Lens' CreateWorkspaceImageResponse (Maybe OperatingSystem)
createWorkspaceImageResponse_operatingSystem = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImageResponse' {Maybe OperatingSystem
operatingSystem :: Maybe OperatingSystem
$sel:operatingSystem:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe OperatingSystem
operatingSystem} -> Maybe OperatingSystem
operatingSystem) (\s :: CreateWorkspaceImageResponse
s@CreateWorkspaceImageResponse' {} Maybe OperatingSystem
a -> CreateWorkspaceImageResponse
s {$sel:operatingSystem:CreateWorkspaceImageResponse' :: Maybe OperatingSystem
operatingSystem = Maybe OperatingSystem
a} :: CreateWorkspaceImageResponse)

-- | The identifier of the Amazon Web Services account that owns the image.
createWorkspaceImageResponse_ownerAccountId :: Lens.Lens' CreateWorkspaceImageResponse (Prelude.Maybe Prelude.Text)
createWorkspaceImageResponse_ownerAccountId :: Lens' CreateWorkspaceImageResponse (Maybe Text)
createWorkspaceImageResponse_ownerAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImageResponse' {Maybe Text
ownerAccountId :: Maybe Text
$sel:ownerAccountId:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe Text
ownerAccountId} -> Maybe Text
ownerAccountId) (\s :: CreateWorkspaceImageResponse
s@CreateWorkspaceImageResponse' {} Maybe Text
a -> CreateWorkspaceImageResponse
s {$sel:ownerAccountId:CreateWorkspaceImageResponse' :: Maybe Text
ownerAccountId = Maybe Text
a} :: CreateWorkspaceImageResponse)

-- | Specifies whether the image is running on dedicated hardware. When Bring
-- Your Own License (BYOL) is enabled, this value is set to DEDICATED. For
-- more information, see
-- <https://docs.aws.amazon.com/workspaces/latest/adminguide/byol-windows-images.htm Bring Your Own Windows Desktop Images.>.
createWorkspaceImageResponse_requiredTenancy :: Lens.Lens' CreateWorkspaceImageResponse (Prelude.Maybe WorkspaceImageRequiredTenancy)
createWorkspaceImageResponse_requiredTenancy :: Lens'
  CreateWorkspaceImageResponse (Maybe WorkspaceImageRequiredTenancy)
createWorkspaceImageResponse_requiredTenancy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImageResponse' {Maybe WorkspaceImageRequiredTenancy
requiredTenancy :: Maybe WorkspaceImageRequiredTenancy
$sel:requiredTenancy:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe WorkspaceImageRequiredTenancy
requiredTenancy} -> Maybe WorkspaceImageRequiredTenancy
requiredTenancy) (\s :: CreateWorkspaceImageResponse
s@CreateWorkspaceImageResponse' {} Maybe WorkspaceImageRequiredTenancy
a -> CreateWorkspaceImageResponse
s {$sel:requiredTenancy:CreateWorkspaceImageResponse' :: Maybe WorkspaceImageRequiredTenancy
requiredTenancy = Maybe WorkspaceImageRequiredTenancy
a} :: CreateWorkspaceImageResponse)

-- | The availability status of the image.
createWorkspaceImageResponse_state :: Lens.Lens' CreateWorkspaceImageResponse (Prelude.Maybe WorkspaceImageState)
createWorkspaceImageResponse_state :: Lens' CreateWorkspaceImageResponse (Maybe WorkspaceImageState)
createWorkspaceImageResponse_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkspaceImageResponse' {Maybe WorkspaceImageState
state :: Maybe WorkspaceImageState
$sel:state:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe WorkspaceImageState
state} -> Maybe WorkspaceImageState
state) (\s :: CreateWorkspaceImageResponse
s@CreateWorkspaceImageResponse' {} Maybe WorkspaceImageState
a -> CreateWorkspaceImageResponse
s {$sel:state:CreateWorkspaceImageResponse' :: Maybe WorkspaceImageState
state = Maybe WorkspaceImageState
a} :: CreateWorkspaceImageResponse)

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

instance Prelude.NFData CreateWorkspaceImageResponse where
  rnf :: CreateWorkspaceImageResponse -> ()
rnf CreateWorkspaceImageResponse' {Int
Maybe Text
Maybe POSIX
Maybe OperatingSystem
Maybe WorkspaceImageRequiredTenancy
Maybe WorkspaceImageState
httpStatus :: Int
state :: Maybe WorkspaceImageState
requiredTenancy :: Maybe WorkspaceImageRequiredTenancy
ownerAccountId :: Maybe Text
operatingSystem :: Maybe OperatingSystem
name :: Maybe Text
imageId :: Maybe Text
description :: Maybe Text
created :: Maybe POSIX
$sel:httpStatus:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Int
$sel:state:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe WorkspaceImageState
$sel:requiredTenancy:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe WorkspaceImageRequiredTenancy
$sel:ownerAccountId:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe Text
$sel:operatingSystem:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe OperatingSystem
$sel:name:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe Text
$sel:imageId:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe Text
$sel:description:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe Text
$sel:created:CreateWorkspaceImageResponse' :: CreateWorkspaceImageResponse -> Maybe POSIX
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
created
      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 Text
imageId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe OperatingSystem
operatingSystem
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
ownerAccountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe WorkspaceImageRequiredTenancy
requiredTenancy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe WorkspaceImageState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus