{-# 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.IoTFleetWise.ListModelManifests
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves a list of vehicle models (model manifests).
--
-- This API operation uses pagination. Specify the @nextToken@ parameter in
-- the request to return more results.
--
-- This operation returns paginated results.
module Amazonka.IoTFleetWise.ListModelManifests
  ( -- * Creating a Request
    ListModelManifests (..),
    newListModelManifests,

    -- * Request Lenses
    listModelManifests_maxResults,
    listModelManifests_nextToken,
    listModelManifests_signalCatalogArn,

    -- * Destructuring the Response
    ListModelManifestsResponse (..),
    newListModelManifestsResponse,

    -- * Response Lenses
    listModelManifestsResponse_nextToken,
    listModelManifestsResponse_summaries,
    listModelManifestsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListModelManifests' smart constructor.
data ListModelManifests = ListModelManifests'
  { -- | The maximum number of items to return, between 1 and 100, inclusive.
    ListModelManifests -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | A pagination token for the next set of results.
    --
    -- If the results of a search are large, only a portion of the results are
    -- returned, and a @nextToken@ pagination token is returned in the
    -- response. To retrieve the next set of results, reissue the search
    -- request and include the returned token. When all results have been
    -- returned, the response does not contain a pagination token value.
    ListModelManifests -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The ARN of a signal catalog. If you specify a signal catalog, only the
    -- vehicle models associated with it are returned.
    ListModelManifests -> Maybe Text
signalCatalogArn :: Prelude.Maybe Prelude.Text
  }
  deriving (ListModelManifests -> ListModelManifests -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListModelManifests -> ListModelManifests -> Bool
$c/= :: ListModelManifests -> ListModelManifests -> Bool
== :: ListModelManifests -> ListModelManifests -> Bool
$c== :: ListModelManifests -> ListModelManifests -> Bool
Prelude.Eq, ReadPrec [ListModelManifests]
ReadPrec ListModelManifests
Int -> ReadS ListModelManifests
ReadS [ListModelManifests]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListModelManifests]
$creadListPrec :: ReadPrec [ListModelManifests]
readPrec :: ReadPrec ListModelManifests
$creadPrec :: ReadPrec ListModelManifests
readList :: ReadS [ListModelManifests]
$creadList :: ReadS [ListModelManifests]
readsPrec :: Int -> ReadS ListModelManifests
$creadsPrec :: Int -> ReadS ListModelManifests
Prelude.Read, Int -> ListModelManifests -> ShowS
[ListModelManifests] -> ShowS
ListModelManifests -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListModelManifests] -> ShowS
$cshowList :: [ListModelManifests] -> ShowS
show :: ListModelManifests -> String
$cshow :: ListModelManifests -> String
showsPrec :: Int -> ListModelManifests -> ShowS
$cshowsPrec :: Int -> ListModelManifests -> ShowS
Prelude.Show, forall x. Rep ListModelManifests x -> ListModelManifests
forall x. ListModelManifests -> Rep ListModelManifests x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListModelManifests x -> ListModelManifests
$cfrom :: forall x. ListModelManifests -> Rep ListModelManifests x
Prelude.Generic)

-- |
-- Create a value of 'ListModelManifests' 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:
--
-- 'maxResults', 'listModelManifests_maxResults' - The maximum number of items to return, between 1 and 100, inclusive.
--
-- 'nextToken', 'listModelManifests_nextToken' - A pagination token for the next set of results.
--
-- If the results of a search are large, only a portion of the results are
-- returned, and a @nextToken@ pagination token is returned in the
-- response. To retrieve the next set of results, reissue the search
-- request and include the returned token. When all results have been
-- returned, the response does not contain a pagination token value.
--
-- 'signalCatalogArn', 'listModelManifests_signalCatalogArn' - The ARN of a signal catalog. If you specify a signal catalog, only the
-- vehicle models associated with it are returned.
newListModelManifests ::
  ListModelManifests
newListModelManifests :: ListModelManifests
newListModelManifests =
  ListModelManifests'
    { $sel:maxResults:ListModelManifests' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListModelManifests' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:signalCatalogArn:ListModelManifests' :: Maybe Text
signalCatalogArn = forall a. Maybe a
Prelude.Nothing
    }

-- | The maximum number of items to return, between 1 and 100, inclusive.
listModelManifests_maxResults :: Lens.Lens' ListModelManifests (Prelude.Maybe Prelude.Natural)
listModelManifests_maxResults :: Lens' ListModelManifests (Maybe Natural)
listModelManifests_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListModelManifests' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListModelManifests' :: ListModelManifests -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListModelManifests
s@ListModelManifests' {} Maybe Natural
a -> ListModelManifests
s {$sel:maxResults:ListModelManifests' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListModelManifests)

-- | A pagination token for the next set of results.
--
-- If the results of a search are large, only a portion of the results are
-- returned, and a @nextToken@ pagination token is returned in the
-- response. To retrieve the next set of results, reissue the search
-- request and include the returned token. When all results have been
-- returned, the response does not contain a pagination token value.
listModelManifests_nextToken :: Lens.Lens' ListModelManifests (Prelude.Maybe Prelude.Text)
listModelManifests_nextToken :: Lens' ListModelManifests (Maybe Text)
listModelManifests_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListModelManifests' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListModelManifests' :: ListModelManifests -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListModelManifests
s@ListModelManifests' {} Maybe Text
a -> ListModelManifests
s {$sel:nextToken:ListModelManifests' :: Maybe Text
nextToken = Maybe Text
a} :: ListModelManifests)

-- | The ARN of a signal catalog. If you specify a signal catalog, only the
-- vehicle models associated with it are returned.
listModelManifests_signalCatalogArn :: Lens.Lens' ListModelManifests (Prelude.Maybe Prelude.Text)
listModelManifests_signalCatalogArn :: Lens' ListModelManifests (Maybe Text)
listModelManifests_signalCatalogArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListModelManifests' {Maybe Text
signalCatalogArn :: Maybe Text
$sel:signalCatalogArn:ListModelManifests' :: ListModelManifests -> Maybe Text
signalCatalogArn} -> Maybe Text
signalCatalogArn) (\s :: ListModelManifests
s@ListModelManifests' {} Maybe Text
a -> ListModelManifests
s {$sel:signalCatalogArn:ListModelManifests' :: Maybe Text
signalCatalogArn = Maybe Text
a} :: ListModelManifests)

instance Core.AWSPager ListModelManifests where
  page :: ListModelManifests
-> AWSResponse ListModelManifests -> Maybe ListModelManifests
page ListModelManifests
rq AWSResponse ListModelManifests
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListModelManifests
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListModelManifestsResponse (Maybe Text)
listModelManifestsResponse_nextToken
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListModelManifests
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListModelManifestsResponse (Maybe [ModelManifestSummary])
listModelManifestsResponse_summaries
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ ListModelManifests
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListModelManifests (Maybe Text)
listModelManifests_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListModelManifests
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListModelManifestsResponse (Maybe Text)
listModelManifestsResponse_nextToken
          forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest ListModelManifests where
  type
    AWSResponse ListModelManifests =
      ListModelManifestsResponse
  request :: (Service -> Service)
-> ListModelManifests -> Request ListModelManifests
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 ListModelManifests
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListModelManifests)))
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 Text
-> Maybe [ModelManifestSummary]
-> Int
-> ListModelManifestsResponse
ListModelManifestsResponse'
            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
"nextToken")
            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
"summaries" 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 ListModelManifests where
  hashWithSalt :: Int -> ListModelManifests -> Int
hashWithSalt Int
_salt ListModelManifests' {Maybe Natural
Maybe Text
signalCatalogArn :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:signalCatalogArn:ListModelManifests' :: ListModelManifests -> Maybe Text
$sel:nextToken:ListModelManifests' :: ListModelManifests -> Maybe Text
$sel:maxResults:ListModelManifests' :: ListModelManifests -> Maybe Natural
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
signalCatalogArn

instance Prelude.NFData ListModelManifests where
  rnf :: ListModelManifests -> ()
rnf ListModelManifests' {Maybe Natural
Maybe Text
signalCatalogArn :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:signalCatalogArn:ListModelManifests' :: ListModelManifests -> Maybe Text
$sel:nextToken:ListModelManifests' :: ListModelManifests -> Maybe Text
$sel:maxResults:ListModelManifests' :: ListModelManifests -> Maybe Natural
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
maxResults
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
signalCatalogArn

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

instance Data.ToJSON ListModelManifests where
  toJSON :: ListModelManifests -> Value
toJSON ListModelManifests' {Maybe Natural
Maybe Text
signalCatalogArn :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:signalCatalogArn:ListModelManifests' :: ListModelManifests -> Maybe Text
$sel:nextToken:ListModelManifests' :: ListModelManifests -> Maybe Text
$sel:maxResults:ListModelManifests' :: ListModelManifests -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"maxResults" 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 Natural
maxResults,
            (Key
"nextToken" 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
nextToken,
            (Key
"signalCatalogArn" 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
signalCatalogArn
          ]
      )

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

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

-- | /See:/ 'newListModelManifestsResponse' smart constructor.
data ListModelManifestsResponse = ListModelManifestsResponse'
  { -- | The token to retrieve the next set of results, or @null@ if there are no
    -- more results.
    ListModelManifestsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A list of information about vehicle models.
    ListModelManifestsResponse -> Maybe [ModelManifestSummary]
summaries :: Prelude.Maybe [ModelManifestSummary],
    -- | The response's http status code.
    ListModelManifestsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListModelManifestsResponse -> ListModelManifestsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListModelManifestsResponse -> ListModelManifestsResponse -> Bool
$c/= :: ListModelManifestsResponse -> ListModelManifestsResponse -> Bool
== :: ListModelManifestsResponse -> ListModelManifestsResponse -> Bool
$c== :: ListModelManifestsResponse -> ListModelManifestsResponse -> Bool
Prelude.Eq, ReadPrec [ListModelManifestsResponse]
ReadPrec ListModelManifestsResponse
Int -> ReadS ListModelManifestsResponse
ReadS [ListModelManifestsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListModelManifestsResponse]
$creadListPrec :: ReadPrec [ListModelManifestsResponse]
readPrec :: ReadPrec ListModelManifestsResponse
$creadPrec :: ReadPrec ListModelManifestsResponse
readList :: ReadS [ListModelManifestsResponse]
$creadList :: ReadS [ListModelManifestsResponse]
readsPrec :: Int -> ReadS ListModelManifestsResponse
$creadsPrec :: Int -> ReadS ListModelManifestsResponse
Prelude.Read, Int -> ListModelManifestsResponse -> ShowS
[ListModelManifestsResponse] -> ShowS
ListModelManifestsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListModelManifestsResponse] -> ShowS
$cshowList :: [ListModelManifestsResponse] -> ShowS
show :: ListModelManifestsResponse -> String
$cshow :: ListModelManifestsResponse -> String
showsPrec :: Int -> ListModelManifestsResponse -> ShowS
$cshowsPrec :: Int -> ListModelManifestsResponse -> ShowS
Prelude.Show, forall x.
Rep ListModelManifestsResponse x -> ListModelManifestsResponse
forall x.
ListModelManifestsResponse -> Rep ListModelManifestsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListModelManifestsResponse x -> ListModelManifestsResponse
$cfrom :: forall x.
ListModelManifestsResponse -> Rep ListModelManifestsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListModelManifestsResponse' 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:
--
-- 'nextToken', 'listModelManifestsResponse_nextToken' - The token to retrieve the next set of results, or @null@ if there are no
-- more results.
--
-- 'summaries', 'listModelManifestsResponse_summaries' - A list of information about vehicle models.
--
-- 'httpStatus', 'listModelManifestsResponse_httpStatus' - The response's http status code.
newListModelManifestsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListModelManifestsResponse
newListModelManifestsResponse :: Int -> ListModelManifestsResponse
newListModelManifestsResponse Int
pHttpStatus_ =
  ListModelManifestsResponse'
    { $sel:nextToken:ListModelManifestsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:summaries:ListModelManifestsResponse' :: Maybe [ModelManifestSummary]
summaries = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListModelManifestsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The token to retrieve the next set of results, or @null@ if there are no
-- more results.
listModelManifestsResponse_nextToken :: Lens.Lens' ListModelManifestsResponse (Prelude.Maybe Prelude.Text)
listModelManifestsResponse_nextToken :: Lens' ListModelManifestsResponse (Maybe Text)
listModelManifestsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListModelManifestsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListModelManifestsResponse' :: ListModelManifestsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListModelManifestsResponse
s@ListModelManifestsResponse' {} Maybe Text
a -> ListModelManifestsResponse
s {$sel:nextToken:ListModelManifestsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListModelManifestsResponse)

-- | A list of information about vehicle models.
listModelManifestsResponse_summaries :: Lens.Lens' ListModelManifestsResponse (Prelude.Maybe [ModelManifestSummary])
listModelManifestsResponse_summaries :: Lens' ListModelManifestsResponse (Maybe [ModelManifestSummary])
listModelManifestsResponse_summaries = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListModelManifestsResponse' {Maybe [ModelManifestSummary]
summaries :: Maybe [ModelManifestSummary]
$sel:summaries:ListModelManifestsResponse' :: ListModelManifestsResponse -> Maybe [ModelManifestSummary]
summaries} -> Maybe [ModelManifestSummary]
summaries) (\s :: ListModelManifestsResponse
s@ListModelManifestsResponse' {} Maybe [ModelManifestSummary]
a -> ListModelManifestsResponse
s {$sel:summaries:ListModelManifestsResponse' :: Maybe [ModelManifestSummary]
summaries = Maybe [ModelManifestSummary]
a} :: ListModelManifestsResponse) 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.
listModelManifestsResponse_httpStatus :: Lens.Lens' ListModelManifestsResponse Prelude.Int
listModelManifestsResponse_httpStatus :: Lens' ListModelManifestsResponse Int
listModelManifestsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListModelManifestsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListModelManifestsResponse' :: ListModelManifestsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListModelManifestsResponse
s@ListModelManifestsResponse' {} Int
a -> ListModelManifestsResponse
s {$sel:httpStatus:ListModelManifestsResponse' :: Int
httpStatus = Int
a} :: ListModelManifestsResponse)

instance Prelude.NFData ListModelManifestsResponse where
  rnf :: ListModelManifestsResponse -> ()
rnf ListModelManifestsResponse' {Int
Maybe [ModelManifestSummary]
Maybe Text
httpStatus :: Int
summaries :: Maybe [ModelManifestSummary]
nextToken :: Maybe Text
$sel:httpStatus:ListModelManifestsResponse' :: ListModelManifestsResponse -> Int
$sel:summaries:ListModelManifestsResponse' :: ListModelManifestsResponse -> Maybe [ModelManifestSummary]
$sel:nextToken:ListModelManifestsResponse' :: ListModelManifestsResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ModelManifestSummary]
summaries
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus