{-# 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.IoTDeviceAdvisor.StartSuiteRun
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Starts a Device Advisor test suite run.
--
-- Requires permission to access the
-- <https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions StartSuiteRun>
-- action.
module Amazonka.IoTDeviceAdvisor.StartSuiteRun
  ( -- * Creating a Request
    StartSuiteRun (..),
    newStartSuiteRun,

    -- * Request Lenses
    startSuiteRun_suiteDefinitionVersion,
    startSuiteRun_tags,
    startSuiteRun_suiteDefinitionId,
    startSuiteRun_suiteRunConfiguration,

    -- * Destructuring the Response
    StartSuiteRunResponse (..),
    newStartSuiteRunResponse,

    -- * Response Lenses
    startSuiteRunResponse_createdAt,
    startSuiteRunResponse_endpoint,
    startSuiteRunResponse_suiteRunArn,
    startSuiteRunResponse_suiteRunId,
    startSuiteRunResponse_httpStatus,
  )
where

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

-- | /See:/ 'newStartSuiteRun' smart constructor.
data StartSuiteRun = StartSuiteRun'
  { -- | Suite definition version of the test suite.
    StartSuiteRun -> Maybe Text
suiteDefinitionVersion :: Prelude.Maybe Prelude.Text,
    -- | The tags to be attached to the suite run.
    StartSuiteRun -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | Suite definition ID of the test suite.
    StartSuiteRun -> Text
suiteDefinitionId :: Prelude.Text,
    -- | Suite run configuration.
    StartSuiteRun -> SuiteRunConfiguration
suiteRunConfiguration :: SuiteRunConfiguration
  }
  deriving (StartSuiteRun -> StartSuiteRun -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartSuiteRun -> StartSuiteRun -> Bool
$c/= :: StartSuiteRun -> StartSuiteRun -> Bool
== :: StartSuiteRun -> StartSuiteRun -> Bool
$c== :: StartSuiteRun -> StartSuiteRun -> Bool
Prelude.Eq, ReadPrec [StartSuiteRun]
ReadPrec StartSuiteRun
Int -> ReadS StartSuiteRun
ReadS [StartSuiteRun]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartSuiteRun]
$creadListPrec :: ReadPrec [StartSuiteRun]
readPrec :: ReadPrec StartSuiteRun
$creadPrec :: ReadPrec StartSuiteRun
readList :: ReadS [StartSuiteRun]
$creadList :: ReadS [StartSuiteRun]
readsPrec :: Int -> ReadS StartSuiteRun
$creadsPrec :: Int -> ReadS StartSuiteRun
Prelude.Read, Int -> StartSuiteRun -> ShowS
[StartSuiteRun] -> ShowS
StartSuiteRun -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartSuiteRun] -> ShowS
$cshowList :: [StartSuiteRun] -> ShowS
show :: StartSuiteRun -> String
$cshow :: StartSuiteRun -> String
showsPrec :: Int -> StartSuiteRun -> ShowS
$cshowsPrec :: Int -> StartSuiteRun -> ShowS
Prelude.Show, forall x. Rep StartSuiteRun x -> StartSuiteRun
forall x. StartSuiteRun -> Rep StartSuiteRun x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartSuiteRun x -> StartSuiteRun
$cfrom :: forall x. StartSuiteRun -> Rep StartSuiteRun x
Prelude.Generic)

-- |
-- Create a value of 'StartSuiteRun' 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:
--
-- 'suiteDefinitionVersion', 'startSuiteRun_suiteDefinitionVersion' - Suite definition version of the test suite.
--
-- 'tags', 'startSuiteRun_tags' - The tags to be attached to the suite run.
--
-- 'suiteDefinitionId', 'startSuiteRun_suiteDefinitionId' - Suite definition ID of the test suite.
--
-- 'suiteRunConfiguration', 'startSuiteRun_suiteRunConfiguration' - Suite run configuration.
newStartSuiteRun ::
  -- | 'suiteDefinitionId'
  Prelude.Text ->
  -- | 'suiteRunConfiguration'
  SuiteRunConfiguration ->
  StartSuiteRun
newStartSuiteRun :: Text -> SuiteRunConfiguration -> StartSuiteRun
newStartSuiteRun
  Text
pSuiteDefinitionId_
  SuiteRunConfiguration
pSuiteRunConfiguration_ =
    StartSuiteRun'
      { $sel:suiteDefinitionVersion:StartSuiteRun' :: Maybe Text
suiteDefinitionVersion =
          forall a. Maybe a
Prelude.Nothing,
        $sel:tags:StartSuiteRun' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:suiteDefinitionId:StartSuiteRun' :: Text
suiteDefinitionId = Text
pSuiteDefinitionId_,
        $sel:suiteRunConfiguration:StartSuiteRun' :: SuiteRunConfiguration
suiteRunConfiguration = SuiteRunConfiguration
pSuiteRunConfiguration_
      }

-- | Suite definition version of the test suite.
startSuiteRun_suiteDefinitionVersion :: Lens.Lens' StartSuiteRun (Prelude.Maybe Prelude.Text)
startSuiteRun_suiteDefinitionVersion :: Lens' StartSuiteRun (Maybe Text)
startSuiteRun_suiteDefinitionVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartSuiteRun' {Maybe Text
suiteDefinitionVersion :: Maybe Text
$sel:suiteDefinitionVersion:StartSuiteRun' :: StartSuiteRun -> Maybe Text
suiteDefinitionVersion} -> Maybe Text
suiteDefinitionVersion) (\s :: StartSuiteRun
s@StartSuiteRun' {} Maybe Text
a -> StartSuiteRun
s {$sel:suiteDefinitionVersion:StartSuiteRun' :: Maybe Text
suiteDefinitionVersion = Maybe Text
a} :: StartSuiteRun)

-- | The tags to be attached to the suite run.
startSuiteRun_tags :: Lens.Lens' StartSuiteRun (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
startSuiteRun_tags :: Lens' StartSuiteRun (Maybe (HashMap Text Text))
startSuiteRun_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartSuiteRun' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:StartSuiteRun' :: StartSuiteRun -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: StartSuiteRun
s@StartSuiteRun' {} Maybe (HashMap Text Text)
a -> StartSuiteRun
s {$sel:tags:StartSuiteRun' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: StartSuiteRun) 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

-- | Suite definition ID of the test suite.
startSuiteRun_suiteDefinitionId :: Lens.Lens' StartSuiteRun Prelude.Text
startSuiteRun_suiteDefinitionId :: Lens' StartSuiteRun Text
startSuiteRun_suiteDefinitionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartSuiteRun' {Text
suiteDefinitionId :: Text
$sel:suiteDefinitionId:StartSuiteRun' :: StartSuiteRun -> Text
suiteDefinitionId} -> Text
suiteDefinitionId) (\s :: StartSuiteRun
s@StartSuiteRun' {} Text
a -> StartSuiteRun
s {$sel:suiteDefinitionId:StartSuiteRun' :: Text
suiteDefinitionId = Text
a} :: StartSuiteRun)

-- | Suite run configuration.
startSuiteRun_suiteRunConfiguration :: Lens.Lens' StartSuiteRun SuiteRunConfiguration
startSuiteRun_suiteRunConfiguration :: Lens' StartSuiteRun SuiteRunConfiguration
startSuiteRun_suiteRunConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartSuiteRun' {SuiteRunConfiguration
suiteRunConfiguration :: SuiteRunConfiguration
$sel:suiteRunConfiguration:StartSuiteRun' :: StartSuiteRun -> SuiteRunConfiguration
suiteRunConfiguration} -> SuiteRunConfiguration
suiteRunConfiguration) (\s :: StartSuiteRun
s@StartSuiteRun' {} SuiteRunConfiguration
a -> StartSuiteRun
s {$sel:suiteRunConfiguration:StartSuiteRun' :: SuiteRunConfiguration
suiteRunConfiguration = SuiteRunConfiguration
a} :: StartSuiteRun)

instance Core.AWSRequest StartSuiteRun where
  type
    AWSResponse StartSuiteRun =
      StartSuiteRunResponse
  request :: (Service -> Service) -> StartSuiteRun -> Request StartSuiteRun
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 StartSuiteRun
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse StartSuiteRun)))
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
-> Int
-> StartSuiteRunResponse
StartSuiteRunResponse'
            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
"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 (Maybe a)
Data..?> Key
"endpoint")
            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
"suiteRunArn")
            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
"suiteRunId")
            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 StartSuiteRun where
  hashWithSalt :: Int -> StartSuiteRun -> Int
hashWithSalt Int
_salt StartSuiteRun' {Maybe Text
Maybe (HashMap Text Text)
Text
SuiteRunConfiguration
suiteRunConfiguration :: SuiteRunConfiguration
suiteDefinitionId :: Text
tags :: Maybe (HashMap Text Text)
suiteDefinitionVersion :: Maybe Text
$sel:suiteRunConfiguration:StartSuiteRun' :: StartSuiteRun -> SuiteRunConfiguration
$sel:suiteDefinitionId:StartSuiteRun' :: StartSuiteRun -> Text
$sel:tags:StartSuiteRun' :: StartSuiteRun -> Maybe (HashMap Text Text)
$sel:suiteDefinitionVersion:StartSuiteRun' :: StartSuiteRun -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
suiteDefinitionVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
suiteDefinitionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` SuiteRunConfiguration
suiteRunConfiguration

instance Prelude.NFData StartSuiteRun where
  rnf :: StartSuiteRun -> ()
rnf StartSuiteRun' {Maybe Text
Maybe (HashMap Text Text)
Text
SuiteRunConfiguration
suiteRunConfiguration :: SuiteRunConfiguration
suiteDefinitionId :: Text
tags :: Maybe (HashMap Text Text)
suiteDefinitionVersion :: Maybe Text
$sel:suiteRunConfiguration:StartSuiteRun' :: StartSuiteRun -> SuiteRunConfiguration
$sel:suiteDefinitionId:StartSuiteRun' :: StartSuiteRun -> Text
$sel:tags:StartSuiteRun' :: StartSuiteRun -> Maybe (HashMap Text Text)
$sel:suiteDefinitionVersion:StartSuiteRun' :: StartSuiteRun -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
suiteDefinitionVersion
      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
suiteDefinitionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf SuiteRunConfiguration
suiteRunConfiguration

instance Data.ToHeaders StartSuiteRun where
  toHeaders :: StartSuiteRun -> 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 StartSuiteRun where
  toJSON :: StartSuiteRun -> Value
toJSON StartSuiteRun' {Maybe Text
Maybe (HashMap Text Text)
Text
SuiteRunConfiguration
suiteRunConfiguration :: SuiteRunConfiguration
suiteDefinitionId :: Text
tags :: Maybe (HashMap Text Text)
suiteDefinitionVersion :: Maybe Text
$sel:suiteRunConfiguration:StartSuiteRun' :: StartSuiteRun -> SuiteRunConfiguration
$sel:suiteDefinitionId:StartSuiteRun' :: StartSuiteRun -> Text
$sel:tags:StartSuiteRun' :: StartSuiteRun -> Maybe (HashMap Text Text)
$sel:suiteDefinitionVersion:StartSuiteRun' :: StartSuiteRun -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"suiteDefinitionVersion" 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
suiteDefinitionVersion,
            (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
"suiteRunConfiguration"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= SuiteRunConfiguration
suiteRunConfiguration
              )
          ]
      )

instance Data.ToPath StartSuiteRun where
  toPath :: StartSuiteRun -> ByteString
toPath StartSuiteRun' {Maybe Text
Maybe (HashMap Text Text)
Text
SuiteRunConfiguration
suiteRunConfiguration :: SuiteRunConfiguration
suiteDefinitionId :: Text
tags :: Maybe (HashMap Text Text)
suiteDefinitionVersion :: Maybe Text
$sel:suiteRunConfiguration:StartSuiteRun' :: StartSuiteRun -> SuiteRunConfiguration
$sel:suiteDefinitionId:StartSuiteRun' :: StartSuiteRun -> Text
$sel:tags:StartSuiteRun' :: StartSuiteRun -> Maybe (HashMap Text Text)
$sel:suiteDefinitionVersion:StartSuiteRun' :: StartSuiteRun -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/suiteDefinitions/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
suiteDefinitionId,
        ByteString
"/suiteRuns"
      ]

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

-- | /See:/ 'newStartSuiteRunResponse' smart constructor.
data StartSuiteRunResponse = StartSuiteRunResponse'
  { -- | Starts a Device Advisor test suite run based on suite create time.
    StartSuiteRunResponse -> Maybe POSIX
createdAt :: Prelude.Maybe Data.POSIX,
    -- | The response of an Device Advisor test endpoint.
    StartSuiteRunResponse -> Maybe Text
endpoint :: Prelude.Maybe Prelude.Text,
    -- | Amazon Resource Name (ARN) of the started suite run.
    StartSuiteRunResponse -> Maybe Text
suiteRunArn :: Prelude.Maybe Prelude.Text,
    -- | Suite Run ID of the started suite run.
    StartSuiteRunResponse -> Maybe Text
suiteRunId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    StartSuiteRunResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (StartSuiteRunResponse -> StartSuiteRunResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartSuiteRunResponse -> StartSuiteRunResponse -> Bool
$c/= :: StartSuiteRunResponse -> StartSuiteRunResponse -> Bool
== :: StartSuiteRunResponse -> StartSuiteRunResponse -> Bool
$c== :: StartSuiteRunResponse -> StartSuiteRunResponse -> Bool
Prelude.Eq, ReadPrec [StartSuiteRunResponse]
ReadPrec StartSuiteRunResponse
Int -> ReadS StartSuiteRunResponse
ReadS [StartSuiteRunResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartSuiteRunResponse]
$creadListPrec :: ReadPrec [StartSuiteRunResponse]
readPrec :: ReadPrec StartSuiteRunResponse
$creadPrec :: ReadPrec StartSuiteRunResponse
readList :: ReadS [StartSuiteRunResponse]
$creadList :: ReadS [StartSuiteRunResponse]
readsPrec :: Int -> ReadS StartSuiteRunResponse
$creadsPrec :: Int -> ReadS StartSuiteRunResponse
Prelude.Read, Int -> StartSuiteRunResponse -> ShowS
[StartSuiteRunResponse] -> ShowS
StartSuiteRunResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartSuiteRunResponse] -> ShowS
$cshowList :: [StartSuiteRunResponse] -> ShowS
show :: StartSuiteRunResponse -> String
$cshow :: StartSuiteRunResponse -> String
showsPrec :: Int -> StartSuiteRunResponse -> ShowS
$cshowsPrec :: Int -> StartSuiteRunResponse -> ShowS
Prelude.Show, forall x. Rep StartSuiteRunResponse x -> StartSuiteRunResponse
forall x. StartSuiteRunResponse -> Rep StartSuiteRunResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartSuiteRunResponse x -> StartSuiteRunResponse
$cfrom :: forall x. StartSuiteRunResponse -> Rep StartSuiteRunResponse x
Prelude.Generic)

-- |
-- Create a value of 'StartSuiteRunResponse' 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:
--
-- 'createdAt', 'startSuiteRunResponse_createdAt' - Starts a Device Advisor test suite run based on suite create time.
--
-- 'endpoint', 'startSuiteRunResponse_endpoint' - The response of an Device Advisor test endpoint.
--
-- 'suiteRunArn', 'startSuiteRunResponse_suiteRunArn' - Amazon Resource Name (ARN) of the started suite run.
--
-- 'suiteRunId', 'startSuiteRunResponse_suiteRunId' - Suite Run ID of the started suite run.
--
-- 'httpStatus', 'startSuiteRunResponse_httpStatus' - The response's http status code.
newStartSuiteRunResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  StartSuiteRunResponse
newStartSuiteRunResponse :: Int -> StartSuiteRunResponse
newStartSuiteRunResponse Int
pHttpStatus_ =
  StartSuiteRunResponse'
    { $sel:createdAt:StartSuiteRunResponse' :: Maybe POSIX
createdAt = forall a. Maybe a
Prelude.Nothing,
      $sel:endpoint:StartSuiteRunResponse' :: Maybe Text
endpoint = forall a. Maybe a
Prelude.Nothing,
      $sel:suiteRunArn:StartSuiteRunResponse' :: Maybe Text
suiteRunArn = forall a. Maybe a
Prelude.Nothing,
      $sel:suiteRunId:StartSuiteRunResponse' :: Maybe Text
suiteRunId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:StartSuiteRunResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Starts a Device Advisor test suite run based on suite create time.
startSuiteRunResponse_createdAt :: Lens.Lens' StartSuiteRunResponse (Prelude.Maybe Prelude.UTCTime)
startSuiteRunResponse_createdAt :: Lens' StartSuiteRunResponse (Maybe UTCTime)
startSuiteRunResponse_createdAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartSuiteRunResponse' {Maybe POSIX
createdAt :: Maybe POSIX
$sel:createdAt:StartSuiteRunResponse' :: StartSuiteRunResponse -> Maybe POSIX
createdAt} -> Maybe POSIX
createdAt) (\s :: StartSuiteRunResponse
s@StartSuiteRunResponse' {} Maybe POSIX
a -> StartSuiteRunResponse
s {$sel:createdAt:StartSuiteRunResponse' :: Maybe POSIX
createdAt = Maybe POSIX
a} :: StartSuiteRunResponse) 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 response of an Device Advisor test endpoint.
startSuiteRunResponse_endpoint :: Lens.Lens' StartSuiteRunResponse (Prelude.Maybe Prelude.Text)
startSuiteRunResponse_endpoint :: Lens' StartSuiteRunResponse (Maybe Text)
startSuiteRunResponse_endpoint = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartSuiteRunResponse' {Maybe Text
endpoint :: Maybe Text
$sel:endpoint:StartSuiteRunResponse' :: StartSuiteRunResponse -> Maybe Text
endpoint} -> Maybe Text
endpoint) (\s :: StartSuiteRunResponse
s@StartSuiteRunResponse' {} Maybe Text
a -> StartSuiteRunResponse
s {$sel:endpoint:StartSuiteRunResponse' :: Maybe Text
endpoint = Maybe Text
a} :: StartSuiteRunResponse)

-- | Amazon Resource Name (ARN) of the started suite run.
startSuiteRunResponse_suiteRunArn :: Lens.Lens' StartSuiteRunResponse (Prelude.Maybe Prelude.Text)
startSuiteRunResponse_suiteRunArn :: Lens' StartSuiteRunResponse (Maybe Text)
startSuiteRunResponse_suiteRunArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartSuiteRunResponse' {Maybe Text
suiteRunArn :: Maybe Text
$sel:suiteRunArn:StartSuiteRunResponse' :: StartSuiteRunResponse -> Maybe Text
suiteRunArn} -> Maybe Text
suiteRunArn) (\s :: StartSuiteRunResponse
s@StartSuiteRunResponse' {} Maybe Text
a -> StartSuiteRunResponse
s {$sel:suiteRunArn:StartSuiteRunResponse' :: Maybe Text
suiteRunArn = Maybe Text
a} :: StartSuiteRunResponse)

-- | Suite Run ID of the started suite run.
startSuiteRunResponse_suiteRunId :: Lens.Lens' StartSuiteRunResponse (Prelude.Maybe Prelude.Text)
startSuiteRunResponse_suiteRunId :: Lens' StartSuiteRunResponse (Maybe Text)
startSuiteRunResponse_suiteRunId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartSuiteRunResponse' {Maybe Text
suiteRunId :: Maybe Text
$sel:suiteRunId:StartSuiteRunResponse' :: StartSuiteRunResponse -> Maybe Text
suiteRunId} -> Maybe Text
suiteRunId) (\s :: StartSuiteRunResponse
s@StartSuiteRunResponse' {} Maybe Text
a -> StartSuiteRunResponse
s {$sel:suiteRunId:StartSuiteRunResponse' :: Maybe Text
suiteRunId = Maybe Text
a} :: StartSuiteRunResponse)

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

instance Prelude.NFData StartSuiteRunResponse where
  rnf :: StartSuiteRunResponse -> ()
rnf StartSuiteRunResponse' {Int
Maybe Text
Maybe POSIX
httpStatus :: Int
suiteRunId :: Maybe Text
suiteRunArn :: Maybe Text
endpoint :: Maybe Text
createdAt :: Maybe POSIX
$sel:httpStatus:StartSuiteRunResponse' :: StartSuiteRunResponse -> Int
$sel:suiteRunId:StartSuiteRunResponse' :: StartSuiteRunResponse -> Maybe Text
$sel:suiteRunArn:StartSuiteRunResponse' :: StartSuiteRunResponse -> Maybe Text
$sel:endpoint:StartSuiteRunResponse' :: StartSuiteRunResponse -> Maybe Text
$sel:createdAt:StartSuiteRunResponse' :: StartSuiteRunResponse -> Maybe POSIX
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
createdAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
endpoint
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
suiteRunArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
suiteRunId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus