{-# 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.LicenseManager.GetLicenseConversionTask
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Gets information about the specified license type conversion task.
module Amazonka.LicenseManager.GetLicenseConversionTask
  ( -- * Creating a Request
    GetLicenseConversionTask (..),
    newGetLicenseConversionTask,

    -- * Request Lenses
    getLicenseConversionTask_licenseConversionTaskId,

    -- * Destructuring the Response
    GetLicenseConversionTaskResponse (..),
    newGetLicenseConversionTaskResponse,

    -- * Response Lenses
    getLicenseConversionTaskResponse_destinationLicenseContext,
    getLicenseConversionTaskResponse_endTime,
    getLicenseConversionTaskResponse_licenseConversionTaskId,
    getLicenseConversionTaskResponse_licenseConversionTime,
    getLicenseConversionTaskResponse_resourceArn,
    getLicenseConversionTaskResponse_sourceLicenseContext,
    getLicenseConversionTaskResponse_startTime,
    getLicenseConversionTaskResponse_status,
    getLicenseConversionTaskResponse_statusMessage,
    getLicenseConversionTaskResponse_httpStatus,
  )
where

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

-- | /See:/ 'newGetLicenseConversionTask' smart constructor.
data GetLicenseConversionTask = GetLicenseConversionTask'
  { -- | ID of the license type conversion task to retrieve information on.
    GetLicenseConversionTask -> Text
licenseConversionTaskId :: Prelude.Text
  }
  deriving (GetLicenseConversionTask -> GetLicenseConversionTask -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetLicenseConversionTask -> GetLicenseConversionTask -> Bool
$c/= :: GetLicenseConversionTask -> GetLicenseConversionTask -> Bool
== :: GetLicenseConversionTask -> GetLicenseConversionTask -> Bool
$c== :: GetLicenseConversionTask -> GetLicenseConversionTask -> Bool
Prelude.Eq, ReadPrec [GetLicenseConversionTask]
ReadPrec GetLicenseConversionTask
Int -> ReadS GetLicenseConversionTask
ReadS [GetLicenseConversionTask]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetLicenseConversionTask]
$creadListPrec :: ReadPrec [GetLicenseConversionTask]
readPrec :: ReadPrec GetLicenseConversionTask
$creadPrec :: ReadPrec GetLicenseConversionTask
readList :: ReadS [GetLicenseConversionTask]
$creadList :: ReadS [GetLicenseConversionTask]
readsPrec :: Int -> ReadS GetLicenseConversionTask
$creadsPrec :: Int -> ReadS GetLicenseConversionTask
Prelude.Read, Int -> GetLicenseConversionTask -> ShowS
[GetLicenseConversionTask] -> ShowS
GetLicenseConversionTask -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetLicenseConversionTask] -> ShowS
$cshowList :: [GetLicenseConversionTask] -> ShowS
show :: GetLicenseConversionTask -> String
$cshow :: GetLicenseConversionTask -> String
showsPrec :: Int -> GetLicenseConversionTask -> ShowS
$cshowsPrec :: Int -> GetLicenseConversionTask -> ShowS
Prelude.Show, forall x.
Rep GetLicenseConversionTask x -> GetLicenseConversionTask
forall x.
GetLicenseConversionTask -> Rep GetLicenseConversionTask x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetLicenseConversionTask x -> GetLicenseConversionTask
$cfrom :: forall x.
GetLicenseConversionTask -> Rep GetLicenseConversionTask x
Prelude.Generic)

-- |
-- Create a value of 'GetLicenseConversionTask' 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:
--
-- 'licenseConversionTaskId', 'getLicenseConversionTask_licenseConversionTaskId' - ID of the license type conversion task to retrieve information on.
newGetLicenseConversionTask ::
  -- | 'licenseConversionTaskId'
  Prelude.Text ->
  GetLicenseConversionTask
newGetLicenseConversionTask :: Text -> GetLicenseConversionTask
newGetLicenseConversionTask Text
pLicenseConversionTaskId_ =
  GetLicenseConversionTask'
    { $sel:licenseConversionTaskId:GetLicenseConversionTask' :: Text
licenseConversionTaskId =
        Text
pLicenseConversionTaskId_
    }

-- | ID of the license type conversion task to retrieve information on.
getLicenseConversionTask_licenseConversionTaskId :: Lens.Lens' GetLicenseConversionTask Prelude.Text
getLicenseConversionTask_licenseConversionTaskId :: Lens' GetLicenseConversionTask Text
getLicenseConversionTask_licenseConversionTaskId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTask' {Text
licenseConversionTaskId :: Text
$sel:licenseConversionTaskId:GetLicenseConversionTask' :: GetLicenseConversionTask -> Text
licenseConversionTaskId} -> Text
licenseConversionTaskId) (\s :: GetLicenseConversionTask
s@GetLicenseConversionTask' {} Text
a -> GetLicenseConversionTask
s {$sel:licenseConversionTaskId:GetLicenseConversionTask' :: Text
licenseConversionTaskId = Text
a} :: GetLicenseConversionTask)

instance Core.AWSRequest GetLicenseConversionTask where
  type
    AWSResponse GetLicenseConversionTask =
      GetLicenseConversionTaskResponse
  request :: (Service -> Service)
-> GetLicenseConversionTask -> Request GetLicenseConversionTask
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 GetLicenseConversionTask
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetLicenseConversionTask)))
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 LicenseConversionContext
-> Maybe POSIX
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe LicenseConversionContext
-> Maybe POSIX
-> Maybe LicenseConversionTaskStatus
-> Maybe Text
-> Int
-> GetLicenseConversionTaskResponse
GetLicenseConversionTaskResponse'
            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
"DestinationLicenseContext")
            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
"EndTime")
            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
"LicenseConversionTaskId")
            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
"LicenseConversionTime")
            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
"ResourceArn")
            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
"SourceLicenseContext")
            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
"StartTime")
            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
"Status")
            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
"StatusMessage")
            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 GetLicenseConversionTask where
  hashWithSalt :: Int -> GetLicenseConversionTask -> Int
hashWithSalt Int
_salt GetLicenseConversionTask' {Text
licenseConversionTaskId :: Text
$sel:licenseConversionTaskId:GetLicenseConversionTask' :: GetLicenseConversionTask -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
licenseConversionTaskId

instance Prelude.NFData GetLicenseConversionTask where
  rnf :: GetLicenseConversionTask -> ()
rnf GetLicenseConversionTask' {Text
licenseConversionTaskId :: Text
$sel:licenseConversionTaskId:GetLicenseConversionTask' :: GetLicenseConversionTask -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
licenseConversionTaskId

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

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

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

-- | /See:/ 'newGetLicenseConversionTaskResponse' smart constructor.
data GetLicenseConversionTaskResponse = GetLicenseConversionTaskResponse'
  { -- | Information about the license type converted to.
    GetLicenseConversionTaskResponse -> Maybe LicenseConversionContext
destinationLicenseContext :: Prelude.Maybe LicenseConversionContext,
    -- | Time at which the license type conversion task was completed.
    GetLicenseConversionTaskResponse -> Maybe POSIX
endTime :: Prelude.Maybe Data.POSIX,
    -- | ID of the license type conversion task.
    GetLicenseConversionTaskResponse -> Maybe Text
licenseConversionTaskId :: Prelude.Maybe Prelude.Text,
    -- | Amount of time to complete the license type conversion.
    GetLicenseConversionTaskResponse -> Maybe POSIX
licenseConversionTime :: Prelude.Maybe Data.POSIX,
    -- | Amazon Resource Names (ARN) of the resources the license conversion task
    -- is associated with.
    GetLicenseConversionTaskResponse -> Maybe Text
resourceArn :: Prelude.Maybe Prelude.Text,
    -- | Information about the license type converted from.
    GetLicenseConversionTaskResponse -> Maybe LicenseConversionContext
sourceLicenseContext :: Prelude.Maybe LicenseConversionContext,
    -- | Time at which the license type conversion task was started .
    GetLicenseConversionTaskResponse -> Maybe POSIX
startTime :: Prelude.Maybe Data.POSIX,
    -- | Status of the license type conversion task.
    GetLicenseConversionTaskResponse
-> Maybe LicenseConversionTaskStatus
status :: Prelude.Maybe LicenseConversionTaskStatus,
    -- | The status message for the conversion task.
    GetLicenseConversionTaskResponse -> Maybe Text
statusMessage :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    GetLicenseConversionTaskResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetLicenseConversionTaskResponse
-> GetLicenseConversionTaskResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetLicenseConversionTaskResponse
-> GetLicenseConversionTaskResponse -> Bool
$c/= :: GetLicenseConversionTaskResponse
-> GetLicenseConversionTaskResponse -> Bool
== :: GetLicenseConversionTaskResponse
-> GetLicenseConversionTaskResponse -> Bool
$c== :: GetLicenseConversionTaskResponse
-> GetLicenseConversionTaskResponse -> Bool
Prelude.Eq, ReadPrec [GetLicenseConversionTaskResponse]
ReadPrec GetLicenseConversionTaskResponse
Int -> ReadS GetLicenseConversionTaskResponse
ReadS [GetLicenseConversionTaskResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetLicenseConversionTaskResponse]
$creadListPrec :: ReadPrec [GetLicenseConversionTaskResponse]
readPrec :: ReadPrec GetLicenseConversionTaskResponse
$creadPrec :: ReadPrec GetLicenseConversionTaskResponse
readList :: ReadS [GetLicenseConversionTaskResponse]
$creadList :: ReadS [GetLicenseConversionTaskResponse]
readsPrec :: Int -> ReadS GetLicenseConversionTaskResponse
$creadsPrec :: Int -> ReadS GetLicenseConversionTaskResponse
Prelude.Read, Int -> GetLicenseConversionTaskResponse -> ShowS
[GetLicenseConversionTaskResponse] -> ShowS
GetLicenseConversionTaskResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetLicenseConversionTaskResponse] -> ShowS
$cshowList :: [GetLicenseConversionTaskResponse] -> ShowS
show :: GetLicenseConversionTaskResponse -> String
$cshow :: GetLicenseConversionTaskResponse -> String
showsPrec :: Int -> GetLicenseConversionTaskResponse -> ShowS
$cshowsPrec :: Int -> GetLicenseConversionTaskResponse -> ShowS
Prelude.Show, forall x.
Rep GetLicenseConversionTaskResponse x
-> GetLicenseConversionTaskResponse
forall x.
GetLicenseConversionTaskResponse
-> Rep GetLicenseConversionTaskResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetLicenseConversionTaskResponse x
-> GetLicenseConversionTaskResponse
$cfrom :: forall x.
GetLicenseConversionTaskResponse
-> Rep GetLicenseConversionTaskResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetLicenseConversionTaskResponse' 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:
--
-- 'destinationLicenseContext', 'getLicenseConversionTaskResponse_destinationLicenseContext' - Information about the license type converted to.
--
-- 'endTime', 'getLicenseConversionTaskResponse_endTime' - Time at which the license type conversion task was completed.
--
-- 'licenseConversionTaskId', 'getLicenseConversionTaskResponse_licenseConversionTaskId' - ID of the license type conversion task.
--
-- 'licenseConversionTime', 'getLicenseConversionTaskResponse_licenseConversionTime' - Amount of time to complete the license type conversion.
--
-- 'resourceArn', 'getLicenseConversionTaskResponse_resourceArn' - Amazon Resource Names (ARN) of the resources the license conversion task
-- is associated with.
--
-- 'sourceLicenseContext', 'getLicenseConversionTaskResponse_sourceLicenseContext' - Information about the license type converted from.
--
-- 'startTime', 'getLicenseConversionTaskResponse_startTime' - Time at which the license type conversion task was started .
--
-- 'status', 'getLicenseConversionTaskResponse_status' - Status of the license type conversion task.
--
-- 'statusMessage', 'getLicenseConversionTaskResponse_statusMessage' - The status message for the conversion task.
--
-- 'httpStatus', 'getLicenseConversionTaskResponse_httpStatus' - The response's http status code.
newGetLicenseConversionTaskResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetLicenseConversionTaskResponse
newGetLicenseConversionTaskResponse :: Int -> GetLicenseConversionTaskResponse
newGetLicenseConversionTaskResponse Int
pHttpStatus_ =
  GetLicenseConversionTaskResponse'
    { $sel:destinationLicenseContext:GetLicenseConversionTaskResponse' :: Maybe LicenseConversionContext
destinationLicenseContext =
        forall a. Maybe a
Prelude.Nothing,
      $sel:endTime:GetLicenseConversionTaskResponse' :: Maybe POSIX
endTime = forall a. Maybe a
Prelude.Nothing,
      $sel:licenseConversionTaskId:GetLicenseConversionTaskResponse' :: Maybe Text
licenseConversionTaskId = forall a. Maybe a
Prelude.Nothing,
      $sel:licenseConversionTime:GetLicenseConversionTaskResponse' :: Maybe POSIX
licenseConversionTime = forall a. Maybe a
Prelude.Nothing,
      $sel:resourceArn:GetLicenseConversionTaskResponse' :: Maybe Text
resourceArn = forall a. Maybe a
Prelude.Nothing,
      $sel:sourceLicenseContext:GetLicenseConversionTaskResponse' :: Maybe LicenseConversionContext
sourceLicenseContext = forall a. Maybe a
Prelude.Nothing,
      $sel:startTime:GetLicenseConversionTaskResponse' :: Maybe POSIX
startTime = forall a. Maybe a
Prelude.Nothing,
      $sel:status:GetLicenseConversionTaskResponse' :: Maybe LicenseConversionTaskStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:statusMessage:GetLicenseConversionTaskResponse' :: Maybe Text
statusMessage = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetLicenseConversionTaskResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the license type converted to.
getLicenseConversionTaskResponse_destinationLicenseContext :: Lens.Lens' GetLicenseConversionTaskResponse (Prelude.Maybe LicenseConversionContext)
getLicenseConversionTaskResponse_destinationLicenseContext :: Lens'
  GetLicenseConversionTaskResponse (Maybe LicenseConversionContext)
getLicenseConversionTaskResponse_destinationLicenseContext = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTaskResponse' {Maybe LicenseConversionContext
destinationLicenseContext :: Maybe LicenseConversionContext
$sel:destinationLicenseContext:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe LicenseConversionContext
destinationLicenseContext} -> Maybe LicenseConversionContext
destinationLicenseContext) (\s :: GetLicenseConversionTaskResponse
s@GetLicenseConversionTaskResponse' {} Maybe LicenseConversionContext
a -> GetLicenseConversionTaskResponse
s {$sel:destinationLicenseContext:GetLicenseConversionTaskResponse' :: Maybe LicenseConversionContext
destinationLicenseContext = Maybe LicenseConversionContext
a} :: GetLicenseConversionTaskResponse)

-- | Time at which the license type conversion task was completed.
getLicenseConversionTaskResponse_endTime :: Lens.Lens' GetLicenseConversionTaskResponse (Prelude.Maybe Prelude.UTCTime)
getLicenseConversionTaskResponse_endTime :: Lens' GetLicenseConversionTaskResponse (Maybe UTCTime)
getLicenseConversionTaskResponse_endTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTaskResponse' {Maybe POSIX
endTime :: Maybe POSIX
$sel:endTime:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe POSIX
endTime} -> Maybe POSIX
endTime) (\s :: GetLicenseConversionTaskResponse
s@GetLicenseConversionTaskResponse' {} Maybe POSIX
a -> GetLicenseConversionTaskResponse
s {$sel:endTime:GetLicenseConversionTaskResponse' :: Maybe POSIX
endTime = Maybe POSIX
a} :: GetLicenseConversionTaskResponse) 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

-- | ID of the license type conversion task.
getLicenseConversionTaskResponse_licenseConversionTaskId :: Lens.Lens' GetLicenseConversionTaskResponse (Prelude.Maybe Prelude.Text)
getLicenseConversionTaskResponse_licenseConversionTaskId :: Lens' GetLicenseConversionTaskResponse (Maybe Text)
getLicenseConversionTaskResponse_licenseConversionTaskId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTaskResponse' {Maybe Text
licenseConversionTaskId :: Maybe Text
$sel:licenseConversionTaskId:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe Text
licenseConversionTaskId} -> Maybe Text
licenseConversionTaskId) (\s :: GetLicenseConversionTaskResponse
s@GetLicenseConversionTaskResponse' {} Maybe Text
a -> GetLicenseConversionTaskResponse
s {$sel:licenseConversionTaskId:GetLicenseConversionTaskResponse' :: Maybe Text
licenseConversionTaskId = Maybe Text
a} :: GetLicenseConversionTaskResponse)

-- | Amount of time to complete the license type conversion.
getLicenseConversionTaskResponse_licenseConversionTime :: Lens.Lens' GetLicenseConversionTaskResponse (Prelude.Maybe Prelude.UTCTime)
getLicenseConversionTaskResponse_licenseConversionTime :: Lens' GetLicenseConversionTaskResponse (Maybe UTCTime)
getLicenseConversionTaskResponse_licenseConversionTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTaskResponse' {Maybe POSIX
licenseConversionTime :: Maybe POSIX
$sel:licenseConversionTime:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe POSIX
licenseConversionTime} -> Maybe POSIX
licenseConversionTime) (\s :: GetLicenseConversionTaskResponse
s@GetLicenseConversionTaskResponse' {} Maybe POSIX
a -> GetLicenseConversionTaskResponse
s {$sel:licenseConversionTime:GetLicenseConversionTaskResponse' :: Maybe POSIX
licenseConversionTime = Maybe POSIX
a} :: GetLicenseConversionTaskResponse) 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

-- | Amazon Resource Names (ARN) of the resources the license conversion task
-- is associated with.
getLicenseConversionTaskResponse_resourceArn :: Lens.Lens' GetLicenseConversionTaskResponse (Prelude.Maybe Prelude.Text)
getLicenseConversionTaskResponse_resourceArn :: Lens' GetLicenseConversionTaskResponse (Maybe Text)
getLicenseConversionTaskResponse_resourceArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTaskResponse' {Maybe Text
resourceArn :: Maybe Text
$sel:resourceArn:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe Text
resourceArn} -> Maybe Text
resourceArn) (\s :: GetLicenseConversionTaskResponse
s@GetLicenseConversionTaskResponse' {} Maybe Text
a -> GetLicenseConversionTaskResponse
s {$sel:resourceArn:GetLicenseConversionTaskResponse' :: Maybe Text
resourceArn = Maybe Text
a} :: GetLicenseConversionTaskResponse)

-- | Information about the license type converted from.
getLicenseConversionTaskResponse_sourceLicenseContext :: Lens.Lens' GetLicenseConversionTaskResponse (Prelude.Maybe LicenseConversionContext)
getLicenseConversionTaskResponse_sourceLicenseContext :: Lens'
  GetLicenseConversionTaskResponse (Maybe LicenseConversionContext)
getLicenseConversionTaskResponse_sourceLicenseContext = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTaskResponse' {Maybe LicenseConversionContext
sourceLicenseContext :: Maybe LicenseConversionContext
$sel:sourceLicenseContext:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe LicenseConversionContext
sourceLicenseContext} -> Maybe LicenseConversionContext
sourceLicenseContext) (\s :: GetLicenseConversionTaskResponse
s@GetLicenseConversionTaskResponse' {} Maybe LicenseConversionContext
a -> GetLicenseConversionTaskResponse
s {$sel:sourceLicenseContext:GetLicenseConversionTaskResponse' :: Maybe LicenseConversionContext
sourceLicenseContext = Maybe LicenseConversionContext
a} :: GetLicenseConversionTaskResponse)

-- | Time at which the license type conversion task was started .
getLicenseConversionTaskResponse_startTime :: Lens.Lens' GetLicenseConversionTaskResponse (Prelude.Maybe Prelude.UTCTime)
getLicenseConversionTaskResponse_startTime :: Lens' GetLicenseConversionTaskResponse (Maybe UTCTime)
getLicenseConversionTaskResponse_startTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTaskResponse' {Maybe POSIX
startTime :: Maybe POSIX
$sel:startTime:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe POSIX
startTime} -> Maybe POSIX
startTime) (\s :: GetLicenseConversionTaskResponse
s@GetLicenseConversionTaskResponse' {} Maybe POSIX
a -> GetLicenseConversionTaskResponse
s {$sel:startTime:GetLicenseConversionTaskResponse' :: Maybe POSIX
startTime = Maybe POSIX
a} :: GetLicenseConversionTaskResponse) 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

-- | Status of the license type conversion task.
getLicenseConversionTaskResponse_status :: Lens.Lens' GetLicenseConversionTaskResponse (Prelude.Maybe LicenseConversionTaskStatus)
getLicenseConversionTaskResponse_status :: Lens'
  GetLicenseConversionTaskResponse
  (Maybe LicenseConversionTaskStatus)
getLicenseConversionTaskResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTaskResponse' {Maybe LicenseConversionTaskStatus
status :: Maybe LicenseConversionTaskStatus
$sel:status:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse
-> Maybe LicenseConversionTaskStatus
status} -> Maybe LicenseConversionTaskStatus
status) (\s :: GetLicenseConversionTaskResponse
s@GetLicenseConversionTaskResponse' {} Maybe LicenseConversionTaskStatus
a -> GetLicenseConversionTaskResponse
s {$sel:status:GetLicenseConversionTaskResponse' :: Maybe LicenseConversionTaskStatus
status = Maybe LicenseConversionTaskStatus
a} :: GetLicenseConversionTaskResponse)

-- | The status message for the conversion task.
getLicenseConversionTaskResponse_statusMessage :: Lens.Lens' GetLicenseConversionTaskResponse (Prelude.Maybe Prelude.Text)
getLicenseConversionTaskResponse_statusMessage :: Lens' GetLicenseConversionTaskResponse (Maybe Text)
getLicenseConversionTaskResponse_statusMessage = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetLicenseConversionTaskResponse' {Maybe Text
statusMessage :: Maybe Text
$sel:statusMessage:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe Text
statusMessage} -> Maybe Text
statusMessage) (\s :: GetLicenseConversionTaskResponse
s@GetLicenseConversionTaskResponse' {} Maybe Text
a -> GetLicenseConversionTaskResponse
s {$sel:statusMessage:GetLicenseConversionTaskResponse' :: Maybe Text
statusMessage = Maybe Text
a} :: GetLicenseConversionTaskResponse)

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

instance
  Prelude.NFData
    GetLicenseConversionTaskResponse
  where
  rnf :: GetLicenseConversionTaskResponse -> ()
rnf GetLicenseConversionTaskResponse' {Int
Maybe Text
Maybe POSIX
Maybe LicenseConversionContext
Maybe LicenseConversionTaskStatus
httpStatus :: Int
statusMessage :: Maybe Text
status :: Maybe LicenseConversionTaskStatus
startTime :: Maybe POSIX
sourceLicenseContext :: Maybe LicenseConversionContext
resourceArn :: Maybe Text
licenseConversionTime :: Maybe POSIX
licenseConversionTaskId :: Maybe Text
endTime :: Maybe POSIX
destinationLicenseContext :: Maybe LicenseConversionContext
$sel:httpStatus:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Int
$sel:statusMessage:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe Text
$sel:status:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse
-> Maybe LicenseConversionTaskStatus
$sel:startTime:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe POSIX
$sel:sourceLicenseContext:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe LicenseConversionContext
$sel:resourceArn:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe Text
$sel:licenseConversionTime:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe POSIX
$sel:licenseConversionTaskId:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe Text
$sel:endTime:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe POSIX
$sel:destinationLicenseContext:GetLicenseConversionTaskResponse' :: GetLicenseConversionTaskResponse -> Maybe LicenseConversionContext
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe LicenseConversionContext
destinationLicenseContext
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
endTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
licenseConversionTaskId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
licenseConversionTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
resourceArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LicenseConversionContext
sourceLicenseContext
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
startTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LicenseConversionTaskStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
statusMessage
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus