{-# 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.DirectoryService.DescribeRegions
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Provides information about the Regions that are configured for
-- multi-Region replication.
--
-- This operation returns paginated results.
module Amazonka.DirectoryService.DescribeRegions
  ( -- * Creating a Request
    DescribeRegions (..),
    newDescribeRegions,

    -- * Request Lenses
    describeRegions_nextToken,
    describeRegions_regionName,
    describeRegions_directoryId,

    -- * Destructuring the Response
    DescribeRegionsResponse (..),
    newDescribeRegionsResponse,

    -- * Response Lenses
    describeRegionsResponse_nextToken,
    describeRegionsResponse_regionsDescription,
    describeRegionsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDescribeRegions' smart constructor.
data DescribeRegions = DescribeRegions'
  { -- | The @DescribeRegionsResult.NextToken@ value from a previous call to
    -- DescribeRegions. Pass null if this is the first call.
    DescribeRegions -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The name of the Region. For example, @us-east-1@.
    DescribeRegions -> Maybe Text
regionName :: Prelude.Maybe Prelude.Text,
    -- | The identifier of the directory.
    DescribeRegions -> Text
directoryId :: Prelude.Text
  }
  deriving (DescribeRegions -> DescribeRegions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeRegions -> DescribeRegions -> Bool
$c/= :: DescribeRegions -> DescribeRegions -> Bool
== :: DescribeRegions -> DescribeRegions -> Bool
$c== :: DescribeRegions -> DescribeRegions -> Bool
Prelude.Eq, ReadPrec [DescribeRegions]
ReadPrec DescribeRegions
Int -> ReadS DescribeRegions
ReadS [DescribeRegions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeRegions]
$creadListPrec :: ReadPrec [DescribeRegions]
readPrec :: ReadPrec DescribeRegions
$creadPrec :: ReadPrec DescribeRegions
readList :: ReadS [DescribeRegions]
$creadList :: ReadS [DescribeRegions]
readsPrec :: Int -> ReadS DescribeRegions
$creadsPrec :: Int -> ReadS DescribeRegions
Prelude.Read, Int -> DescribeRegions -> ShowS
[DescribeRegions] -> ShowS
DescribeRegions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeRegions] -> ShowS
$cshowList :: [DescribeRegions] -> ShowS
show :: DescribeRegions -> String
$cshow :: DescribeRegions -> String
showsPrec :: Int -> DescribeRegions -> ShowS
$cshowsPrec :: Int -> DescribeRegions -> ShowS
Prelude.Show, forall x. Rep DescribeRegions x -> DescribeRegions
forall x. DescribeRegions -> Rep DescribeRegions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeRegions x -> DescribeRegions
$cfrom :: forall x. DescribeRegions -> Rep DescribeRegions x
Prelude.Generic)

-- |
-- Create a value of 'DescribeRegions' 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', 'describeRegions_nextToken' - The @DescribeRegionsResult.NextToken@ value from a previous call to
-- DescribeRegions. Pass null if this is the first call.
--
-- 'regionName', 'describeRegions_regionName' - The name of the Region. For example, @us-east-1@.
--
-- 'directoryId', 'describeRegions_directoryId' - The identifier of the directory.
newDescribeRegions ::
  -- | 'directoryId'
  Prelude.Text ->
  DescribeRegions
newDescribeRegions :: Text -> DescribeRegions
newDescribeRegions Text
pDirectoryId_ =
  DescribeRegions'
    { $sel:nextToken:DescribeRegions' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:regionName:DescribeRegions' :: Maybe Text
regionName = forall a. Maybe a
Prelude.Nothing,
      $sel:directoryId:DescribeRegions' :: Text
directoryId = Text
pDirectoryId_
    }

-- | The @DescribeRegionsResult.NextToken@ value from a previous call to
-- DescribeRegions. Pass null if this is the first call.
describeRegions_nextToken :: Lens.Lens' DescribeRegions (Prelude.Maybe Prelude.Text)
describeRegions_nextToken :: Lens' DescribeRegions (Maybe Text)
describeRegions_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeRegions' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeRegions' :: DescribeRegions -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeRegions
s@DescribeRegions' {} Maybe Text
a -> DescribeRegions
s {$sel:nextToken:DescribeRegions' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeRegions)

-- | The name of the Region. For example, @us-east-1@.
describeRegions_regionName :: Lens.Lens' DescribeRegions (Prelude.Maybe Prelude.Text)
describeRegions_regionName :: Lens' DescribeRegions (Maybe Text)
describeRegions_regionName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeRegions' {Maybe Text
regionName :: Maybe Text
$sel:regionName:DescribeRegions' :: DescribeRegions -> Maybe Text
regionName} -> Maybe Text
regionName) (\s :: DescribeRegions
s@DescribeRegions' {} Maybe Text
a -> DescribeRegions
s {$sel:regionName:DescribeRegions' :: Maybe Text
regionName = Maybe Text
a} :: DescribeRegions)

-- | The identifier of the directory.
describeRegions_directoryId :: Lens.Lens' DescribeRegions Prelude.Text
describeRegions_directoryId :: Lens' DescribeRegions Text
describeRegions_directoryId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeRegions' {Text
directoryId :: Text
$sel:directoryId:DescribeRegions' :: DescribeRegions -> Text
directoryId} -> Text
directoryId) (\s :: DescribeRegions
s@DescribeRegions' {} Text
a -> DescribeRegions
s {$sel:directoryId:DescribeRegions' :: Text
directoryId = Text
a} :: DescribeRegions)

instance Core.AWSPager DescribeRegions where
  page :: DescribeRegions
-> AWSResponse DescribeRegions -> Maybe DescribeRegions
page DescribeRegions
rq AWSResponse DescribeRegions
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse DescribeRegions
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeRegionsResponse (Maybe Text)
describeRegionsResponse_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 DescribeRegions
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeRegionsResponse (Maybe [RegionDescription])
describeRegionsResponse_regionsDescription
            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.$ DescribeRegions
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' DescribeRegions (Maybe Text)
describeRegions_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse DescribeRegions
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeRegionsResponse (Maybe Text)
describeRegionsResponse_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 DescribeRegions where
  type
    AWSResponse DescribeRegions =
      DescribeRegionsResponse
  request :: (Service -> Service) -> DescribeRegions -> Request DescribeRegions
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 DescribeRegions
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DescribeRegions)))
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 [RegionDescription] -> Int -> DescribeRegionsResponse
DescribeRegionsResponse'
            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
"RegionsDescription"
                            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 DescribeRegions where
  hashWithSalt :: Int -> DescribeRegions -> Int
hashWithSalt Int
_salt DescribeRegions' {Maybe Text
Text
directoryId :: Text
regionName :: Maybe Text
nextToken :: Maybe Text
$sel:directoryId:DescribeRegions' :: DescribeRegions -> Text
$sel:regionName:DescribeRegions' :: DescribeRegions -> Maybe Text
$sel:nextToken:DescribeRegions' :: DescribeRegions -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
regionName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
directoryId

instance Prelude.NFData DescribeRegions where
  rnf :: DescribeRegions -> ()
rnf DescribeRegions' {Maybe Text
Text
directoryId :: Text
regionName :: Maybe Text
nextToken :: Maybe Text
$sel:directoryId:DescribeRegions' :: DescribeRegions -> Text
$sel:regionName:DescribeRegions' :: DescribeRegions -> Maybe Text
$sel:nextToken:DescribeRegions' :: DescribeRegions -> 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 Text
regionName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
directoryId

instance Data.ToHeaders DescribeRegions where
  toHeaders :: DescribeRegions -> 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
"DirectoryService_20150416.DescribeRegions" ::
                          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 DescribeRegions where
  toJSON :: DescribeRegions -> Value
toJSON DescribeRegions' {Maybe Text
Text
directoryId :: Text
regionName :: Maybe Text
nextToken :: Maybe Text
$sel:directoryId:DescribeRegions' :: DescribeRegions -> Text
$sel:regionName:DescribeRegions' :: DescribeRegions -> Maybe Text
$sel:nextToken:DescribeRegions' :: DescribeRegions -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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
"RegionName" 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
regionName,
            forall a. a -> Maybe a
Prelude.Just (Key
"DirectoryId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
directoryId)
          ]
      )

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

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

-- | /See:/ 'newDescribeRegionsResponse' smart constructor.
data DescribeRegionsResponse = DescribeRegionsResponse'
  { -- | If not null, more results are available. Pass this value for the
    -- @NextToken@ parameter in a subsequent call to DescribeRegions to
    -- retrieve the next set of items.
    DescribeRegionsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | List of Region information related to the directory for each replicated
    -- Region.
    DescribeRegionsResponse -> Maybe [RegionDescription]
regionsDescription :: Prelude.Maybe [RegionDescription],
    -- | The response's http status code.
    DescribeRegionsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeRegionsResponse -> DescribeRegionsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeRegionsResponse -> DescribeRegionsResponse -> Bool
$c/= :: DescribeRegionsResponse -> DescribeRegionsResponse -> Bool
== :: DescribeRegionsResponse -> DescribeRegionsResponse -> Bool
$c== :: DescribeRegionsResponse -> DescribeRegionsResponse -> Bool
Prelude.Eq, ReadPrec [DescribeRegionsResponse]
ReadPrec DescribeRegionsResponse
Int -> ReadS DescribeRegionsResponse
ReadS [DescribeRegionsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeRegionsResponse]
$creadListPrec :: ReadPrec [DescribeRegionsResponse]
readPrec :: ReadPrec DescribeRegionsResponse
$creadPrec :: ReadPrec DescribeRegionsResponse
readList :: ReadS [DescribeRegionsResponse]
$creadList :: ReadS [DescribeRegionsResponse]
readsPrec :: Int -> ReadS DescribeRegionsResponse
$creadsPrec :: Int -> ReadS DescribeRegionsResponse
Prelude.Read, Int -> DescribeRegionsResponse -> ShowS
[DescribeRegionsResponse] -> ShowS
DescribeRegionsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeRegionsResponse] -> ShowS
$cshowList :: [DescribeRegionsResponse] -> ShowS
show :: DescribeRegionsResponse -> String
$cshow :: DescribeRegionsResponse -> String
showsPrec :: Int -> DescribeRegionsResponse -> ShowS
$cshowsPrec :: Int -> DescribeRegionsResponse -> ShowS
Prelude.Show, forall x. Rep DescribeRegionsResponse x -> DescribeRegionsResponse
forall x. DescribeRegionsResponse -> Rep DescribeRegionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeRegionsResponse x -> DescribeRegionsResponse
$cfrom :: forall x. DescribeRegionsResponse -> Rep DescribeRegionsResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeRegionsResponse' 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', 'describeRegionsResponse_nextToken' - If not null, more results are available. Pass this value for the
-- @NextToken@ parameter in a subsequent call to DescribeRegions to
-- retrieve the next set of items.
--
-- 'regionsDescription', 'describeRegionsResponse_regionsDescription' - List of Region information related to the directory for each replicated
-- Region.
--
-- 'httpStatus', 'describeRegionsResponse_httpStatus' - The response's http status code.
newDescribeRegionsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeRegionsResponse
newDescribeRegionsResponse :: Int -> DescribeRegionsResponse
newDescribeRegionsResponse Int
pHttpStatus_ =
  DescribeRegionsResponse'
    { $sel:nextToken:DescribeRegionsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:regionsDescription:DescribeRegionsResponse' :: Maybe [RegionDescription]
regionsDescription = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeRegionsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | If not null, more results are available. Pass this value for the
-- @NextToken@ parameter in a subsequent call to DescribeRegions to
-- retrieve the next set of items.
describeRegionsResponse_nextToken :: Lens.Lens' DescribeRegionsResponse (Prelude.Maybe Prelude.Text)
describeRegionsResponse_nextToken :: Lens' DescribeRegionsResponse (Maybe Text)
describeRegionsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeRegionsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeRegionsResponse' :: DescribeRegionsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeRegionsResponse
s@DescribeRegionsResponse' {} Maybe Text
a -> DescribeRegionsResponse
s {$sel:nextToken:DescribeRegionsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeRegionsResponse)

-- | List of Region information related to the directory for each replicated
-- Region.
describeRegionsResponse_regionsDescription :: Lens.Lens' DescribeRegionsResponse (Prelude.Maybe [RegionDescription])
describeRegionsResponse_regionsDescription :: Lens' DescribeRegionsResponse (Maybe [RegionDescription])
describeRegionsResponse_regionsDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeRegionsResponse' {Maybe [RegionDescription]
regionsDescription :: Maybe [RegionDescription]
$sel:regionsDescription:DescribeRegionsResponse' :: DescribeRegionsResponse -> Maybe [RegionDescription]
regionsDescription} -> Maybe [RegionDescription]
regionsDescription) (\s :: DescribeRegionsResponse
s@DescribeRegionsResponse' {} Maybe [RegionDescription]
a -> DescribeRegionsResponse
s {$sel:regionsDescription:DescribeRegionsResponse' :: Maybe [RegionDescription]
regionsDescription = Maybe [RegionDescription]
a} :: DescribeRegionsResponse) 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.
describeRegionsResponse_httpStatus :: Lens.Lens' DescribeRegionsResponse Prelude.Int
describeRegionsResponse_httpStatus :: Lens' DescribeRegionsResponse Int
describeRegionsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeRegionsResponse' {Int
httpStatus :: Int
$sel:httpStatus:DescribeRegionsResponse' :: DescribeRegionsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: DescribeRegionsResponse
s@DescribeRegionsResponse' {} Int
a -> DescribeRegionsResponse
s {$sel:httpStatus:DescribeRegionsResponse' :: Int
httpStatus = Int
a} :: DescribeRegionsResponse)

instance Prelude.NFData DescribeRegionsResponse where
  rnf :: DescribeRegionsResponse -> ()
rnf DescribeRegionsResponse' {Int
Maybe [RegionDescription]
Maybe Text
httpStatus :: Int
regionsDescription :: Maybe [RegionDescription]
nextToken :: Maybe Text
$sel:httpStatus:DescribeRegionsResponse' :: DescribeRegionsResponse -> Int
$sel:regionsDescription:DescribeRegionsResponse' :: DescribeRegionsResponse -> Maybe [RegionDescription]
$sel:nextToken:DescribeRegionsResponse' :: DescribeRegionsResponse -> 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 [RegionDescription]
regionsDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus