{-# 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.ECS.DescribeTaskSets
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Describes the task sets in the specified cluster and service. This is
-- used when a service uses the @EXTERNAL@ deployment controller type. For
-- more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html Amazon ECS Deployment Types>
-- in the /Amazon Elastic Container Service Developer Guide/.
module Amazonka.ECS.DescribeTaskSets
  ( -- * Creating a Request
    DescribeTaskSets (..),
    newDescribeTaskSets,

    -- * Request Lenses
    describeTaskSets_include,
    describeTaskSets_taskSets,
    describeTaskSets_cluster,
    describeTaskSets_service,

    -- * Destructuring the Response
    DescribeTaskSetsResponse (..),
    newDescribeTaskSetsResponse,

    -- * Response Lenses
    describeTaskSetsResponse_failures,
    describeTaskSetsResponse_taskSets,
    describeTaskSetsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDescribeTaskSets' smart constructor.
data DescribeTaskSets = DescribeTaskSets'
  { -- | Specifies whether to see the resource tags for the task set. If @TAGS@
    -- is specified, the tags are included in the response. If this field is
    -- omitted, tags aren\'t included in the response.
    DescribeTaskSets -> Maybe [TaskSetField]
include :: Prelude.Maybe [TaskSetField],
    -- | The ID or full Amazon Resource Name (ARN) of task sets to describe.
    DescribeTaskSets -> Maybe [Text]
taskSets :: Prelude.Maybe [Prelude.Text],
    -- | The short name or full Amazon Resource Name (ARN) of the cluster that
    -- hosts the service that the task sets exist in.
    DescribeTaskSets -> Text
cluster :: Prelude.Text,
    -- | The short name or full Amazon Resource Name (ARN) of the service that
    -- the task sets exist in.
    DescribeTaskSets -> Text
service :: Prelude.Text
  }
  deriving (DescribeTaskSets -> DescribeTaskSets -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeTaskSets -> DescribeTaskSets -> Bool
$c/= :: DescribeTaskSets -> DescribeTaskSets -> Bool
== :: DescribeTaskSets -> DescribeTaskSets -> Bool
$c== :: DescribeTaskSets -> DescribeTaskSets -> Bool
Prelude.Eq, ReadPrec [DescribeTaskSets]
ReadPrec DescribeTaskSets
Int -> ReadS DescribeTaskSets
ReadS [DescribeTaskSets]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeTaskSets]
$creadListPrec :: ReadPrec [DescribeTaskSets]
readPrec :: ReadPrec DescribeTaskSets
$creadPrec :: ReadPrec DescribeTaskSets
readList :: ReadS [DescribeTaskSets]
$creadList :: ReadS [DescribeTaskSets]
readsPrec :: Int -> ReadS DescribeTaskSets
$creadsPrec :: Int -> ReadS DescribeTaskSets
Prelude.Read, Int -> DescribeTaskSets -> ShowS
[DescribeTaskSets] -> ShowS
DescribeTaskSets -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeTaskSets] -> ShowS
$cshowList :: [DescribeTaskSets] -> ShowS
show :: DescribeTaskSets -> String
$cshow :: DescribeTaskSets -> String
showsPrec :: Int -> DescribeTaskSets -> ShowS
$cshowsPrec :: Int -> DescribeTaskSets -> ShowS
Prelude.Show, forall x. Rep DescribeTaskSets x -> DescribeTaskSets
forall x. DescribeTaskSets -> Rep DescribeTaskSets x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeTaskSets x -> DescribeTaskSets
$cfrom :: forall x. DescribeTaskSets -> Rep DescribeTaskSets x
Prelude.Generic)

-- |
-- Create a value of 'DescribeTaskSets' 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:
--
-- 'include', 'describeTaskSets_include' - Specifies whether to see the resource tags for the task set. If @TAGS@
-- is specified, the tags are included in the response. If this field is
-- omitted, tags aren\'t included in the response.
--
-- 'taskSets', 'describeTaskSets_taskSets' - The ID or full Amazon Resource Name (ARN) of task sets to describe.
--
-- 'cluster', 'describeTaskSets_cluster' - The short name or full Amazon Resource Name (ARN) of the cluster that
-- hosts the service that the task sets exist in.
--
-- 'service', 'describeTaskSets_service' - The short name or full Amazon Resource Name (ARN) of the service that
-- the task sets exist in.
newDescribeTaskSets ::
  -- | 'cluster'
  Prelude.Text ->
  -- | 'service'
  Prelude.Text ->
  DescribeTaskSets
newDescribeTaskSets :: Text -> Text -> DescribeTaskSets
newDescribeTaskSets Text
pCluster_ Text
pService_ =
  DescribeTaskSets'
    { $sel:include:DescribeTaskSets' :: Maybe [TaskSetField]
include = forall a. Maybe a
Prelude.Nothing,
      $sel:taskSets:DescribeTaskSets' :: Maybe [Text]
taskSets = forall a. Maybe a
Prelude.Nothing,
      $sel:cluster:DescribeTaskSets' :: Text
cluster = Text
pCluster_,
      $sel:service:DescribeTaskSets' :: Text
service = Text
pService_
    }

-- | Specifies whether to see the resource tags for the task set. If @TAGS@
-- is specified, the tags are included in the response. If this field is
-- omitted, tags aren\'t included in the response.
describeTaskSets_include :: Lens.Lens' DescribeTaskSets (Prelude.Maybe [TaskSetField])
describeTaskSets_include :: Lens' DescribeTaskSets (Maybe [TaskSetField])
describeTaskSets_include = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeTaskSets' {Maybe [TaskSetField]
include :: Maybe [TaskSetField]
$sel:include:DescribeTaskSets' :: DescribeTaskSets -> Maybe [TaskSetField]
include} -> Maybe [TaskSetField]
include) (\s :: DescribeTaskSets
s@DescribeTaskSets' {} Maybe [TaskSetField]
a -> DescribeTaskSets
s {$sel:include:DescribeTaskSets' :: Maybe [TaskSetField]
include = Maybe [TaskSetField]
a} :: DescribeTaskSets) 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 or full Amazon Resource Name (ARN) of task sets to describe.
describeTaskSets_taskSets :: Lens.Lens' DescribeTaskSets (Prelude.Maybe [Prelude.Text])
describeTaskSets_taskSets :: Lens' DescribeTaskSets (Maybe [Text])
describeTaskSets_taskSets = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeTaskSets' {Maybe [Text]
taskSets :: Maybe [Text]
$sel:taskSets:DescribeTaskSets' :: DescribeTaskSets -> Maybe [Text]
taskSets} -> Maybe [Text]
taskSets) (\s :: DescribeTaskSets
s@DescribeTaskSets' {} Maybe [Text]
a -> DescribeTaskSets
s {$sel:taskSets:DescribeTaskSets' :: Maybe [Text]
taskSets = Maybe [Text]
a} :: DescribeTaskSets) 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 short name or full Amazon Resource Name (ARN) of the cluster that
-- hosts the service that the task sets exist in.
describeTaskSets_cluster :: Lens.Lens' DescribeTaskSets Prelude.Text
describeTaskSets_cluster :: Lens' DescribeTaskSets Text
describeTaskSets_cluster = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeTaskSets' {Text
cluster :: Text
$sel:cluster:DescribeTaskSets' :: DescribeTaskSets -> Text
cluster} -> Text
cluster) (\s :: DescribeTaskSets
s@DescribeTaskSets' {} Text
a -> DescribeTaskSets
s {$sel:cluster:DescribeTaskSets' :: Text
cluster = Text
a} :: DescribeTaskSets)

-- | The short name or full Amazon Resource Name (ARN) of the service that
-- the task sets exist in.
describeTaskSets_service :: Lens.Lens' DescribeTaskSets Prelude.Text
describeTaskSets_service :: Lens' DescribeTaskSets Text
describeTaskSets_service = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeTaskSets' {Text
service :: Text
$sel:service:DescribeTaskSets' :: DescribeTaskSets -> Text
service} -> Text
service) (\s :: DescribeTaskSets
s@DescribeTaskSets' {} Text
a -> DescribeTaskSets
s {$sel:service:DescribeTaskSets' :: Text
service = Text
a} :: DescribeTaskSets)

instance Core.AWSRequest DescribeTaskSets where
  type
    AWSResponse DescribeTaskSets =
      DescribeTaskSetsResponse
  request :: (Service -> Service)
-> DescribeTaskSets -> Request DescribeTaskSets
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 DescribeTaskSets
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DescribeTaskSets)))
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 [Failure]
-> Maybe [TaskSet] -> Int -> DescribeTaskSetsResponse
DescribeTaskSetsResponse'
            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
"failures" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            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
"taskSets" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            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 DescribeTaskSets where
  hashWithSalt :: Int -> DescribeTaskSets -> Int
hashWithSalt Int
_salt DescribeTaskSets' {Maybe [Text]
Maybe [TaskSetField]
Text
service :: Text
cluster :: Text
taskSets :: Maybe [Text]
include :: Maybe [TaskSetField]
$sel:service:DescribeTaskSets' :: DescribeTaskSets -> Text
$sel:cluster:DescribeTaskSets' :: DescribeTaskSets -> Text
$sel:taskSets:DescribeTaskSets' :: DescribeTaskSets -> Maybe [Text]
$sel:include:DescribeTaskSets' :: DescribeTaskSets -> Maybe [TaskSetField]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TaskSetField]
include
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
taskSets
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
cluster
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
service

instance Prelude.NFData DescribeTaskSets where
  rnf :: DescribeTaskSets -> ()
rnf DescribeTaskSets' {Maybe [Text]
Maybe [TaskSetField]
Text
service :: Text
cluster :: Text
taskSets :: Maybe [Text]
include :: Maybe [TaskSetField]
$sel:service:DescribeTaskSets' :: DescribeTaskSets -> Text
$sel:cluster:DescribeTaskSets' :: DescribeTaskSets -> Text
$sel:taskSets:DescribeTaskSets' :: DescribeTaskSets -> Maybe [Text]
$sel:include:DescribeTaskSets' :: DescribeTaskSets -> Maybe [TaskSetField]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [TaskSetField]
include
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
taskSets
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
cluster
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
service

instance Data.ToHeaders DescribeTaskSets where
  toHeaders :: DescribeTaskSets -> 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
"AmazonEC2ContainerServiceV20141113.DescribeTaskSets" ::
                          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 DescribeTaskSets where
  toJSON :: DescribeTaskSets -> Value
toJSON DescribeTaskSets' {Maybe [Text]
Maybe [TaskSetField]
Text
service :: Text
cluster :: Text
taskSets :: Maybe [Text]
include :: Maybe [TaskSetField]
$sel:service:DescribeTaskSets' :: DescribeTaskSets -> Text
$sel:cluster:DescribeTaskSets' :: DescribeTaskSets -> Text
$sel:taskSets:DescribeTaskSets' :: DescribeTaskSets -> Maybe [Text]
$sel:include:DescribeTaskSets' :: DescribeTaskSets -> Maybe [TaskSetField]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"include" 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 [TaskSetField]
include,
            (Key
"taskSets" 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]
taskSets,
            forall a. a -> Maybe a
Prelude.Just (Key
"cluster" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
cluster),
            forall a. a -> Maybe a
Prelude.Just (Key
"service" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
service)
          ]
      )

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

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

-- | /See:/ 'newDescribeTaskSetsResponse' smart constructor.
data DescribeTaskSetsResponse = DescribeTaskSetsResponse'
  { -- | Any failures associated with the call.
    DescribeTaskSetsResponse -> Maybe [Failure]
failures :: Prelude.Maybe [Failure],
    -- | The list of task sets described.
    DescribeTaskSetsResponse -> Maybe [TaskSet]
taskSets :: Prelude.Maybe [TaskSet],
    -- | The response's http status code.
    DescribeTaskSetsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeTaskSetsResponse -> DescribeTaskSetsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeTaskSetsResponse -> DescribeTaskSetsResponse -> Bool
$c/= :: DescribeTaskSetsResponse -> DescribeTaskSetsResponse -> Bool
== :: DescribeTaskSetsResponse -> DescribeTaskSetsResponse -> Bool
$c== :: DescribeTaskSetsResponse -> DescribeTaskSetsResponse -> Bool
Prelude.Eq, ReadPrec [DescribeTaskSetsResponse]
ReadPrec DescribeTaskSetsResponse
Int -> ReadS DescribeTaskSetsResponse
ReadS [DescribeTaskSetsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeTaskSetsResponse]
$creadListPrec :: ReadPrec [DescribeTaskSetsResponse]
readPrec :: ReadPrec DescribeTaskSetsResponse
$creadPrec :: ReadPrec DescribeTaskSetsResponse
readList :: ReadS [DescribeTaskSetsResponse]
$creadList :: ReadS [DescribeTaskSetsResponse]
readsPrec :: Int -> ReadS DescribeTaskSetsResponse
$creadsPrec :: Int -> ReadS DescribeTaskSetsResponse
Prelude.Read, Int -> DescribeTaskSetsResponse -> ShowS
[DescribeTaskSetsResponse] -> ShowS
DescribeTaskSetsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeTaskSetsResponse] -> ShowS
$cshowList :: [DescribeTaskSetsResponse] -> ShowS
show :: DescribeTaskSetsResponse -> String
$cshow :: DescribeTaskSetsResponse -> String
showsPrec :: Int -> DescribeTaskSetsResponse -> ShowS
$cshowsPrec :: Int -> DescribeTaskSetsResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeTaskSetsResponse x -> DescribeTaskSetsResponse
forall x.
DescribeTaskSetsResponse -> Rep DescribeTaskSetsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeTaskSetsResponse x -> DescribeTaskSetsResponse
$cfrom :: forall x.
DescribeTaskSetsResponse -> Rep DescribeTaskSetsResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeTaskSetsResponse' 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:
--
-- 'failures', 'describeTaskSetsResponse_failures' - Any failures associated with the call.
--
-- 'taskSets', 'describeTaskSetsResponse_taskSets' - The list of task sets described.
--
-- 'httpStatus', 'describeTaskSetsResponse_httpStatus' - The response's http status code.
newDescribeTaskSetsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeTaskSetsResponse
newDescribeTaskSetsResponse :: Int -> DescribeTaskSetsResponse
newDescribeTaskSetsResponse Int
pHttpStatus_ =
  DescribeTaskSetsResponse'
    { $sel:failures:DescribeTaskSetsResponse' :: Maybe [Failure]
failures =
        forall a. Maybe a
Prelude.Nothing,
      $sel:taskSets:DescribeTaskSetsResponse' :: Maybe [TaskSet]
taskSets = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeTaskSetsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Any failures associated with the call.
describeTaskSetsResponse_failures :: Lens.Lens' DescribeTaskSetsResponse (Prelude.Maybe [Failure])
describeTaskSetsResponse_failures :: Lens' DescribeTaskSetsResponse (Maybe [Failure])
describeTaskSetsResponse_failures = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeTaskSetsResponse' {Maybe [Failure]
failures :: Maybe [Failure]
$sel:failures:DescribeTaskSetsResponse' :: DescribeTaskSetsResponse -> Maybe [Failure]
failures} -> Maybe [Failure]
failures) (\s :: DescribeTaskSetsResponse
s@DescribeTaskSetsResponse' {} Maybe [Failure]
a -> DescribeTaskSetsResponse
s {$sel:failures:DescribeTaskSetsResponse' :: Maybe [Failure]
failures = Maybe [Failure]
a} :: DescribeTaskSetsResponse) 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 list of task sets described.
describeTaskSetsResponse_taskSets :: Lens.Lens' DescribeTaskSetsResponse (Prelude.Maybe [TaskSet])
describeTaskSetsResponse_taskSets :: Lens' DescribeTaskSetsResponse (Maybe [TaskSet])
describeTaskSetsResponse_taskSets = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeTaskSetsResponse' {Maybe [TaskSet]
taskSets :: Maybe [TaskSet]
$sel:taskSets:DescribeTaskSetsResponse' :: DescribeTaskSetsResponse -> Maybe [TaskSet]
taskSets} -> Maybe [TaskSet]
taskSets) (\s :: DescribeTaskSetsResponse
s@DescribeTaskSetsResponse' {} Maybe [TaskSet]
a -> DescribeTaskSetsResponse
s {$sel:taskSets:DescribeTaskSetsResponse' :: Maybe [TaskSet]
taskSets = Maybe [TaskSet]
a} :: DescribeTaskSetsResponse) 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 response's http status code.
describeTaskSetsResponse_httpStatus :: Lens.Lens' DescribeTaskSetsResponse Prelude.Int
describeTaskSetsResponse_httpStatus :: Lens' DescribeTaskSetsResponse Int
describeTaskSetsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeTaskSetsResponse' {Int
httpStatus :: Int
$sel:httpStatus:DescribeTaskSetsResponse' :: DescribeTaskSetsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: DescribeTaskSetsResponse
s@DescribeTaskSetsResponse' {} Int
a -> DescribeTaskSetsResponse
s {$sel:httpStatus:DescribeTaskSetsResponse' :: Int
httpStatus = Int
a} :: DescribeTaskSetsResponse)

instance Prelude.NFData DescribeTaskSetsResponse where
  rnf :: DescribeTaskSetsResponse -> ()
rnf DescribeTaskSetsResponse' {Int
Maybe [Failure]
Maybe [TaskSet]
httpStatus :: Int
taskSets :: Maybe [TaskSet]
failures :: Maybe [Failure]
$sel:httpStatus:DescribeTaskSetsResponse' :: DescribeTaskSetsResponse -> Int
$sel:taskSets:DescribeTaskSetsResponse' :: DescribeTaskSetsResponse -> Maybe [TaskSet]
$sel:failures:DescribeTaskSetsResponse' :: DescribeTaskSetsResponse -> Maybe [Failure]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Failure]
failures
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [TaskSet]
taskSets
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus