{-# 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.SNS.ListSubscriptions
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns a list of the requester\'s subscriptions. Each call returns a
-- limited list of subscriptions, up to 100. If there are more
-- subscriptions, a @NextToken@ is also returned. Use the @NextToken@
-- parameter in a new @ListSubscriptions@ call to get further results.
--
-- This action is throttled at 30 transactions per second (TPS).
--
-- This operation returns paginated results.
module Amazonka.SNS.ListSubscriptions
  ( -- * Creating a Request
    ListSubscriptions (..),
    newListSubscriptions,

    -- * Request Lenses
    listSubscriptions_nextToken,

    -- * Destructuring the Response
    ListSubscriptionsResponse (..),
    newListSubscriptionsResponse,

    -- * Response Lenses
    listSubscriptionsResponse_nextToken,
    listSubscriptionsResponse_subscriptions,
    listSubscriptionsResponse_httpStatus,
  )
where

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

-- | Input for ListSubscriptions action.
--
-- /See:/ 'newListSubscriptions' smart constructor.
data ListSubscriptions = ListSubscriptions'
  { -- | Token returned by the previous @ListSubscriptions@ request.
    ListSubscriptions -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (ListSubscriptions -> ListSubscriptions -> Bool
(ListSubscriptions -> ListSubscriptions -> Bool)
-> (ListSubscriptions -> ListSubscriptions -> Bool)
-> Eq ListSubscriptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListSubscriptions -> ListSubscriptions -> Bool
== :: ListSubscriptions -> ListSubscriptions -> Bool
$c/= :: ListSubscriptions -> ListSubscriptions -> Bool
/= :: ListSubscriptions -> ListSubscriptions -> Bool
Prelude.Eq, ReadPrec [ListSubscriptions]
ReadPrec ListSubscriptions
Int -> ReadS ListSubscriptions
ReadS [ListSubscriptions]
(Int -> ReadS ListSubscriptions)
-> ReadS [ListSubscriptions]
-> ReadPrec ListSubscriptions
-> ReadPrec [ListSubscriptions]
-> Read ListSubscriptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ListSubscriptions
readsPrec :: Int -> ReadS ListSubscriptions
$creadList :: ReadS [ListSubscriptions]
readList :: ReadS [ListSubscriptions]
$creadPrec :: ReadPrec ListSubscriptions
readPrec :: ReadPrec ListSubscriptions
$creadListPrec :: ReadPrec [ListSubscriptions]
readListPrec :: ReadPrec [ListSubscriptions]
Prelude.Read, Int -> ListSubscriptions -> ShowS
[ListSubscriptions] -> ShowS
ListSubscriptions -> String
(Int -> ListSubscriptions -> ShowS)
-> (ListSubscriptions -> String)
-> ([ListSubscriptions] -> ShowS)
-> Show ListSubscriptions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListSubscriptions -> ShowS
showsPrec :: Int -> ListSubscriptions -> ShowS
$cshow :: ListSubscriptions -> String
show :: ListSubscriptions -> String
$cshowList :: [ListSubscriptions] -> ShowS
showList :: [ListSubscriptions] -> ShowS
Prelude.Show, (forall x. ListSubscriptions -> Rep ListSubscriptions x)
-> (forall x. Rep ListSubscriptions x -> ListSubscriptions)
-> Generic ListSubscriptions
forall x. Rep ListSubscriptions x -> ListSubscriptions
forall x. ListSubscriptions -> Rep ListSubscriptions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ListSubscriptions -> Rep ListSubscriptions x
from :: forall x. ListSubscriptions -> Rep ListSubscriptions x
$cto :: forall x. Rep ListSubscriptions x -> ListSubscriptions
to :: forall x. Rep ListSubscriptions x -> ListSubscriptions
Prelude.Generic)

-- |
-- Create a value of 'ListSubscriptions' 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', 'listSubscriptions_nextToken' - Token returned by the previous @ListSubscriptions@ request.
newListSubscriptions ::
  ListSubscriptions
newListSubscriptions :: ListSubscriptions
newListSubscriptions =
  ListSubscriptions' {nextToken :: Maybe Text
nextToken = Maybe Text
forall a. Maybe a
Prelude.Nothing}

-- | Token returned by the previous @ListSubscriptions@ request.
listSubscriptions_nextToken :: Lens.Lens' ListSubscriptions (Prelude.Maybe Prelude.Text)
listSubscriptions_nextToken :: Lens' ListSubscriptions (Maybe Text)
listSubscriptions_nextToken = (ListSubscriptions -> Maybe Text)
-> (ListSubscriptions -> Maybe Text -> ListSubscriptions)
-> Lens' ListSubscriptions (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSubscriptions' {Maybe Text
nextToken :: ListSubscriptions -> Maybe Text
nextToken :: Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListSubscriptions
s@ListSubscriptions' {} Maybe Text
a -> ListSubscriptions
s {nextToken = a} :: ListSubscriptions)

instance Core.AWSPager ListSubscriptions where
  page :: ListSubscriptions
-> AWSResponse ListSubscriptions -> Maybe ListSubscriptions
page ListSubscriptions
rq AWSResponse ListSubscriptions
rs
    | Maybe Text -> Bool
forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListSubscriptions
ListSubscriptionsResponse
rs
            ListSubscriptionsResponse
-> Getting (First Text) ListSubscriptionsResponse Text
-> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? (Maybe Text -> Const (First Text) (Maybe Text))
-> ListSubscriptionsResponse
-> Const (First Text) ListSubscriptionsResponse
Lens' ListSubscriptionsResponse (Maybe Text)
listSubscriptionsResponse_nextToken
            ((Maybe Text -> Const (First Text) (Maybe Text))
 -> ListSubscriptionsResponse
 -> Const (First Text) ListSubscriptionsResponse)
-> ((Text -> Const (First Text) Text)
    -> Maybe Text -> Const (First Text) (Maybe Text))
-> Getting (First Text) ListSubscriptionsResponse Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (Text -> Const (First Text) Text)
-> Maybe Text -> Const (First Text) (Maybe Text)
forall a a' (f :: * -> *).
Applicative f =>
(a -> f a') -> Maybe a -> f (Maybe a')
Lens._Just
        ) =
        Maybe ListSubscriptions
forall a. Maybe a
Prelude.Nothing
    | Maybe [Subscription] -> Bool
forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListSubscriptions
ListSubscriptionsResponse
rs
            ListSubscriptionsResponse
-> Getting
     (First [Subscription]) ListSubscriptionsResponse [Subscription]
-> Maybe [Subscription]
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? (Maybe [Subscription]
 -> Const (First [Subscription]) (Maybe [Subscription]))
-> ListSubscriptionsResponse
-> Const (First [Subscription]) ListSubscriptionsResponse
Lens' ListSubscriptionsResponse (Maybe [Subscription])
listSubscriptionsResponse_subscriptions
            ((Maybe [Subscription]
  -> Const (First [Subscription]) (Maybe [Subscription]))
 -> ListSubscriptionsResponse
 -> Const (First [Subscription]) ListSubscriptionsResponse)
-> (([Subscription] -> Const (First [Subscription]) [Subscription])
    -> Maybe [Subscription]
    -> Const (First [Subscription]) (Maybe [Subscription]))
-> Getting
     (First [Subscription]) ListSubscriptionsResponse [Subscription]
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. ([Subscription] -> Const (First [Subscription]) [Subscription])
-> Maybe [Subscription]
-> Const (First [Subscription]) (Maybe [Subscription])
forall a a' (f :: * -> *).
Applicative f =>
(a -> f a') -> Maybe a -> f (Maybe a')
Lens._Just
        ) =
        Maybe ListSubscriptions
forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        ListSubscriptions -> Maybe ListSubscriptions
forall a. a -> Maybe a
Prelude.Just (ListSubscriptions -> Maybe ListSubscriptions)
-> ListSubscriptions -> Maybe ListSubscriptions
forall a b. (a -> b) -> a -> b
Prelude.$
          ListSubscriptions
rq
            ListSubscriptions
-> (ListSubscriptions -> ListSubscriptions) -> ListSubscriptions
forall a b. a -> (a -> b) -> b
Prelude.& (Maybe Text -> Identity (Maybe Text))
-> ListSubscriptions -> Identity ListSubscriptions
Lens' ListSubscriptions (Maybe Text)
listSubscriptions_nextToken
              ((Maybe Text -> Identity (Maybe Text))
 -> ListSubscriptions -> Identity ListSubscriptions)
-> Maybe Text -> ListSubscriptions -> ListSubscriptions
forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListSubscriptions
ListSubscriptionsResponse
rs
              ListSubscriptionsResponse
-> Getting (First Text) ListSubscriptionsResponse Text
-> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? (Maybe Text -> Const (First Text) (Maybe Text))
-> ListSubscriptionsResponse
-> Const (First Text) ListSubscriptionsResponse
Lens' ListSubscriptionsResponse (Maybe Text)
listSubscriptionsResponse_nextToken
              ((Maybe Text -> Const (First Text) (Maybe Text))
 -> ListSubscriptionsResponse
 -> Const (First Text) ListSubscriptionsResponse)
-> ((Text -> Const (First Text) Text)
    -> Maybe Text -> Const (First Text) (Maybe Text))
-> Getting (First Text) ListSubscriptionsResponse Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (Text -> Const (First Text) Text)
-> Maybe Text -> Const (First Text) (Maybe Text)
forall a a' (f :: * -> *).
Applicative f =>
(a -> f a') -> Maybe a -> f (Maybe a')
Lens._Just

instance Core.AWSRequest ListSubscriptions where
  type
    AWSResponse ListSubscriptions =
      ListSubscriptionsResponse
  request :: (Service -> Service)
-> ListSubscriptions -> Request ListSubscriptions
request Service -> Service
overrides =
    Service -> ListSubscriptions -> Request ListSubscriptions
forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListSubscriptions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListSubscriptions)))
response =
    Text
-> (Int
    -> ResponseHeaders
    -> [Node]
    -> Either String (AWSResponse ListSubscriptions))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListSubscriptions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListSubscriptions)))
forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"ListSubscriptionsResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe Text
-> Maybe [Subscription] -> Int -> ListSubscriptionsResponse
ListSubscriptionsResponse'
            (Maybe Text
 -> Maybe [Subscription] -> Int -> ListSubscriptionsResponse)
-> Either String (Maybe Text)
-> Either
     String (Maybe [Subscription] -> Int -> ListSubscriptionsResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"NextToken")
            Either
  String (Maybe [Subscription] -> Int -> ListSubscriptionsResponse)
-> Either String (Maybe [Subscription])
-> Either String (Int -> ListSubscriptionsResponse)
forall a b.
Either String (a -> b) -> Either String a -> Either String b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x [Node] -> Text -> Either String (Maybe [Node])
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Subscriptions" Either String (Maybe [Node]) -> [Node] -> Either String [Node]
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ [Node]
forall a. Monoid a => a
Prelude.mempty
                            Either String [Node]
-> ([Node] -> Either String (Maybe [Subscription]))
-> Either String (Maybe [Subscription])
forall a b.
Either String a -> (a -> Either String b) -> Either String b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= ([Node] -> Either String [Subscription])
-> [Node] -> Either String (Maybe [Subscription])
forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (Text -> [Node] -> Either String [Subscription]
forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                        )
            Either String (Int -> ListSubscriptionsResponse)
-> Either String Int -> Either String ListSubscriptionsResponse
forall a b.
Either String (a -> b) -> Either String a -> Either String b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall a. a -> Either String a
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable ListSubscriptions where
  hashWithSalt :: Int -> ListSubscriptions -> Int
hashWithSalt Int
_salt ListSubscriptions' {Maybe Text
nextToken :: ListSubscriptions -> Maybe Text
nextToken :: Maybe Text
..} =
    Int
_salt Int -> Maybe Text -> Int
forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken

instance Prelude.NFData ListSubscriptions where
  rnf :: ListSubscriptions -> ()
rnf ListSubscriptions' {Maybe Text
nextToken :: ListSubscriptions -> Maybe Text
nextToken :: Maybe Text
..} = Maybe Text -> ()
forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken

instance Data.ToHeaders ListSubscriptions where
  toHeaders :: ListSubscriptions -> ResponseHeaders
toHeaders = ResponseHeaders -> ListSubscriptions -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const ResponseHeaders
forall a. Monoid a => a
Prelude.mempty

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

instance Data.ToQuery ListSubscriptions where
  toQuery :: ListSubscriptions -> QueryString
toQuery ListSubscriptions' {Maybe Text
nextToken :: ListSubscriptions -> Maybe Text
nextToken :: Maybe Text
..} =
    [QueryString] -> QueryString
forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          ByteString -> ByteString -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ListSubscriptions" :: Prelude.ByteString),
        ByteString
"Version"
          ByteString -> ByteString -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2010-03-31" :: Prelude.ByteString),
        ByteString
"NextToken" ByteString -> Maybe Text -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken
      ]

-- | Response for ListSubscriptions action
--
-- /See:/ 'newListSubscriptionsResponse' smart constructor.
data ListSubscriptionsResponse = ListSubscriptionsResponse'
  { -- | Token to pass along to the next @ListSubscriptions@ request. This
    -- element is returned if there are more subscriptions to retrieve.
    ListSubscriptionsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A list of subscriptions.
    ListSubscriptionsResponse -> Maybe [Subscription]
subscriptions :: Prelude.Maybe [Subscription],
    -- | The response's http status code.
    ListSubscriptionsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListSubscriptionsResponse -> ListSubscriptionsResponse -> Bool
(ListSubscriptionsResponse -> ListSubscriptionsResponse -> Bool)
-> (ListSubscriptionsResponse -> ListSubscriptionsResponse -> Bool)
-> Eq ListSubscriptionsResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListSubscriptionsResponse -> ListSubscriptionsResponse -> Bool
== :: ListSubscriptionsResponse -> ListSubscriptionsResponse -> Bool
$c/= :: ListSubscriptionsResponse -> ListSubscriptionsResponse -> Bool
/= :: ListSubscriptionsResponse -> ListSubscriptionsResponse -> Bool
Prelude.Eq, ReadPrec [ListSubscriptionsResponse]
ReadPrec ListSubscriptionsResponse
Int -> ReadS ListSubscriptionsResponse
ReadS [ListSubscriptionsResponse]
(Int -> ReadS ListSubscriptionsResponse)
-> ReadS [ListSubscriptionsResponse]
-> ReadPrec ListSubscriptionsResponse
-> ReadPrec [ListSubscriptionsResponse]
-> Read ListSubscriptionsResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ListSubscriptionsResponse
readsPrec :: Int -> ReadS ListSubscriptionsResponse
$creadList :: ReadS [ListSubscriptionsResponse]
readList :: ReadS [ListSubscriptionsResponse]
$creadPrec :: ReadPrec ListSubscriptionsResponse
readPrec :: ReadPrec ListSubscriptionsResponse
$creadListPrec :: ReadPrec [ListSubscriptionsResponse]
readListPrec :: ReadPrec [ListSubscriptionsResponse]
Prelude.Read, Int -> ListSubscriptionsResponse -> ShowS
[ListSubscriptionsResponse] -> ShowS
ListSubscriptionsResponse -> String
(Int -> ListSubscriptionsResponse -> ShowS)
-> (ListSubscriptionsResponse -> String)
-> ([ListSubscriptionsResponse] -> ShowS)
-> Show ListSubscriptionsResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListSubscriptionsResponse -> ShowS
showsPrec :: Int -> ListSubscriptionsResponse -> ShowS
$cshow :: ListSubscriptionsResponse -> String
show :: ListSubscriptionsResponse -> String
$cshowList :: [ListSubscriptionsResponse] -> ShowS
showList :: [ListSubscriptionsResponse] -> ShowS
Prelude.Show, (forall x.
 ListSubscriptionsResponse -> Rep ListSubscriptionsResponse x)
-> (forall x.
    Rep ListSubscriptionsResponse x -> ListSubscriptionsResponse)
-> Generic ListSubscriptionsResponse
forall x.
Rep ListSubscriptionsResponse x -> ListSubscriptionsResponse
forall x.
ListSubscriptionsResponse -> Rep ListSubscriptionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
ListSubscriptionsResponse -> Rep ListSubscriptionsResponse x
from :: forall x.
ListSubscriptionsResponse -> Rep ListSubscriptionsResponse x
$cto :: forall x.
Rep ListSubscriptionsResponse x -> ListSubscriptionsResponse
to :: forall x.
Rep ListSubscriptionsResponse x -> ListSubscriptionsResponse
Prelude.Generic)

-- |
-- Create a value of 'ListSubscriptionsResponse' 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', 'listSubscriptionsResponse_nextToken' - Token to pass along to the next @ListSubscriptions@ request. This
-- element is returned if there are more subscriptions to retrieve.
--
-- 'subscriptions', 'listSubscriptionsResponse_subscriptions' - A list of subscriptions.
--
-- 'httpStatus', 'listSubscriptionsResponse_httpStatus' - The response's http status code.
newListSubscriptionsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListSubscriptionsResponse
newListSubscriptionsResponse :: Int -> ListSubscriptionsResponse
newListSubscriptionsResponse Int
pHttpStatus_ =
  ListSubscriptionsResponse'
    { nextToken :: Maybe Text
nextToken =
        Maybe Text
forall a. Maybe a
Prelude.Nothing,
      subscriptions :: Maybe [Subscription]
subscriptions = Maybe [Subscription]
forall a. Maybe a
Prelude.Nothing,
      httpStatus :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Token to pass along to the next @ListSubscriptions@ request. This
-- element is returned if there are more subscriptions to retrieve.
listSubscriptionsResponse_nextToken :: Lens.Lens' ListSubscriptionsResponse (Prelude.Maybe Prelude.Text)
listSubscriptionsResponse_nextToken :: Lens' ListSubscriptionsResponse (Maybe Text)
listSubscriptionsResponse_nextToken = (ListSubscriptionsResponse -> Maybe Text)
-> (ListSubscriptionsResponse
    -> Maybe Text -> ListSubscriptionsResponse)
-> Lens' ListSubscriptionsResponse (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSubscriptionsResponse' {Maybe Text
nextToken :: ListSubscriptionsResponse -> Maybe Text
nextToken :: Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListSubscriptionsResponse
s@ListSubscriptionsResponse' {} Maybe Text
a -> ListSubscriptionsResponse
s {nextToken = a} :: ListSubscriptionsResponse)

-- | A list of subscriptions.
listSubscriptionsResponse_subscriptions :: Lens.Lens' ListSubscriptionsResponse (Prelude.Maybe [Subscription])
listSubscriptionsResponse_subscriptions :: Lens' ListSubscriptionsResponse (Maybe [Subscription])
listSubscriptionsResponse_subscriptions = (ListSubscriptionsResponse -> Maybe [Subscription])
-> (ListSubscriptionsResponse
    -> Maybe [Subscription] -> ListSubscriptionsResponse)
-> Lens' ListSubscriptionsResponse (Maybe [Subscription])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSubscriptionsResponse' {Maybe [Subscription]
subscriptions :: ListSubscriptionsResponse -> Maybe [Subscription]
subscriptions :: Maybe [Subscription]
subscriptions} -> Maybe [Subscription]
subscriptions) (\s :: ListSubscriptionsResponse
s@ListSubscriptionsResponse' {} Maybe [Subscription]
a -> ListSubscriptionsResponse
s {subscriptions = a} :: ListSubscriptionsResponse) ((Maybe [Subscription] -> f (Maybe [Subscription]))
 -> ListSubscriptionsResponse -> f ListSubscriptionsResponse)
-> ((Maybe [Subscription] -> f (Maybe [Subscription]))
    -> Maybe [Subscription] -> f (Maybe [Subscription]))
-> (Maybe [Subscription] -> f (Maybe [Subscription]))
-> ListSubscriptionsResponse
-> f ListSubscriptionsResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Subscription] [Subscription] [Subscription] [Subscription]
-> Iso
     (Maybe [Subscription])
     (Maybe [Subscription])
     (Maybe [Subscription])
     (Maybe [Subscription])
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 AnIso [Subscription] [Subscription] [Subscription] [Subscription]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Iso [Subscription] [Subscription] [Subscription] [Subscription]
Lens.coerced

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

instance Prelude.NFData ListSubscriptionsResponse where
  rnf :: ListSubscriptionsResponse -> ()
rnf ListSubscriptionsResponse' {Int
Maybe [Subscription]
Maybe Text
nextToken :: ListSubscriptionsResponse -> Maybe Text
subscriptions :: ListSubscriptionsResponse -> Maybe [Subscription]
httpStatus :: ListSubscriptionsResponse -> Int
nextToken :: Maybe Text
subscriptions :: Maybe [Subscription]
httpStatus :: Int
..} =
    Maybe Text -> ()
forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken () -> () -> ()
forall a b. a -> b -> b
`Prelude.seq`
      Maybe [Subscription] -> ()
forall a. NFData a => a -> ()
Prelude.rnf Maybe [Subscription]
subscriptions () -> () -> ()
forall a b. a -> b -> b
`Prelude.seq`
        Int -> ()
forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus