{-# 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.Snowball.DescribeAddresses
-- 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 specified number of @ADDRESS@ objects. Calling this API in one
-- of the US regions will return addresses from the list of all addresses
-- associated with this account in all US regions.
--
-- This operation returns paginated results.
module Amazonka.Snowball.DescribeAddresses
  ( -- * Creating a Request
    DescribeAddresses (..),
    newDescribeAddresses,

    -- * Request Lenses
    describeAddresses_maxResults,
    describeAddresses_nextToken,

    -- * Destructuring the Response
    DescribeAddressesResponse (..),
    newDescribeAddressesResponse,

    -- * Response Lenses
    describeAddressesResponse_addresses,
    describeAddressesResponse_nextToken,
    describeAddressesResponse_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.Snowball.Types

-- | /See:/ 'newDescribeAddresses' smart constructor.
data DescribeAddresses = DescribeAddresses'
  { -- | The number of @ADDRESS@ objects to return.
    DescribeAddresses -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | HTTP requests are stateless. To identify what object comes \"next\" in
    -- the list of @ADDRESS@ objects, you have the option of specifying a value
    -- for @NextToken@ as the starting point for your list of returned
    -- addresses.
    DescribeAddresses -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (DescribeAddresses -> DescribeAddresses -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeAddresses -> DescribeAddresses -> Bool
$c/= :: DescribeAddresses -> DescribeAddresses -> Bool
== :: DescribeAddresses -> DescribeAddresses -> Bool
$c== :: DescribeAddresses -> DescribeAddresses -> Bool
Prelude.Eq, ReadPrec [DescribeAddresses]
ReadPrec DescribeAddresses
Int -> ReadS DescribeAddresses
ReadS [DescribeAddresses]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeAddresses]
$creadListPrec :: ReadPrec [DescribeAddresses]
readPrec :: ReadPrec DescribeAddresses
$creadPrec :: ReadPrec DescribeAddresses
readList :: ReadS [DescribeAddresses]
$creadList :: ReadS [DescribeAddresses]
readsPrec :: Int -> ReadS DescribeAddresses
$creadsPrec :: Int -> ReadS DescribeAddresses
Prelude.Read, Int -> DescribeAddresses -> ShowS
[DescribeAddresses] -> ShowS
DescribeAddresses -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeAddresses] -> ShowS
$cshowList :: [DescribeAddresses] -> ShowS
show :: DescribeAddresses -> String
$cshow :: DescribeAddresses -> String
showsPrec :: Int -> DescribeAddresses -> ShowS
$cshowsPrec :: Int -> DescribeAddresses -> ShowS
Prelude.Show, forall x. Rep DescribeAddresses x -> DescribeAddresses
forall x. DescribeAddresses -> Rep DescribeAddresses x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeAddresses x -> DescribeAddresses
$cfrom :: forall x. DescribeAddresses -> Rep DescribeAddresses x
Prelude.Generic)

-- |
-- Create a value of 'DescribeAddresses' 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', 'describeAddresses_maxResults' - The number of @ADDRESS@ objects to return.
--
-- 'nextToken', 'describeAddresses_nextToken' - HTTP requests are stateless. To identify what object comes \"next\" in
-- the list of @ADDRESS@ objects, you have the option of specifying a value
-- for @NextToken@ as the starting point for your list of returned
-- addresses.
newDescribeAddresses ::
  DescribeAddresses
newDescribeAddresses :: DescribeAddresses
newDescribeAddresses =
  DescribeAddresses'
    { $sel:maxResults:DescribeAddresses' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeAddresses' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | The number of @ADDRESS@ objects to return.
describeAddresses_maxResults :: Lens.Lens' DescribeAddresses (Prelude.Maybe Prelude.Natural)
describeAddresses_maxResults :: Lens' DescribeAddresses (Maybe Natural)
describeAddresses_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAddresses' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:DescribeAddresses' :: DescribeAddresses -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: DescribeAddresses
s@DescribeAddresses' {} Maybe Natural
a -> DescribeAddresses
s {$sel:maxResults:DescribeAddresses' :: Maybe Natural
maxResults = Maybe Natural
a} :: DescribeAddresses)

-- | HTTP requests are stateless. To identify what object comes \"next\" in
-- the list of @ADDRESS@ objects, you have the option of specifying a value
-- for @NextToken@ as the starting point for your list of returned
-- addresses.
describeAddresses_nextToken :: Lens.Lens' DescribeAddresses (Prelude.Maybe Prelude.Text)
describeAddresses_nextToken :: Lens' DescribeAddresses (Maybe Text)
describeAddresses_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAddresses' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeAddresses' :: DescribeAddresses -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeAddresses
s@DescribeAddresses' {} Maybe Text
a -> DescribeAddresses
s {$sel:nextToken:DescribeAddresses' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeAddresses)

instance Core.AWSPager DescribeAddresses where
  page :: DescribeAddresses
-> AWSResponse DescribeAddresses -> Maybe DescribeAddresses
page DescribeAddresses
rq AWSResponse DescribeAddresses
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse DescribeAddresses
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeAddressesResponse (Maybe Text)
describeAddressesResponse_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 DescribeAddresses
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeAddressesResponse (Maybe [Address])
describeAddressesResponse_addresses
            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.$ DescribeAddresses
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' DescribeAddresses (Maybe Text)
describeAddresses_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse DescribeAddresses
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeAddressesResponse (Maybe Text)
describeAddressesResponse_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 DescribeAddresses where
  type
    AWSResponse DescribeAddresses =
      DescribeAddressesResponse
  request :: (Service -> Service)
-> DescribeAddresses -> Request DescribeAddresses
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 DescribeAddresses
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DescribeAddresses)))
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 [Address] -> Maybe Text -> Int -> DescribeAddressesResponse
DescribeAddressesResponse'
            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
"Addresses" 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
"NextToken")
            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 DescribeAddresses where
  hashWithSalt :: Int -> DescribeAddresses -> Int
hashWithSalt Int
_salt DescribeAddresses' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:DescribeAddresses' :: DescribeAddresses -> Maybe Text
$sel:maxResults:DescribeAddresses' :: DescribeAddresses -> 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

instance Prelude.NFData DescribeAddresses where
  rnf :: DescribeAddresses -> ()
rnf DescribeAddresses' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:DescribeAddresses' :: DescribeAddresses -> Maybe Text
$sel:maxResults:DescribeAddresses' :: DescribeAddresses -> 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

instance Data.ToHeaders DescribeAddresses where
  toHeaders :: DescribeAddresses -> 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
"AWSIESnowballJobManagementService.DescribeAddresses" ::
                          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 DescribeAddresses where
  toJSON :: DescribeAddresses -> Value
toJSON DescribeAddresses' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:DescribeAddresses' :: DescribeAddresses -> Maybe Text
$sel:maxResults:DescribeAddresses' :: DescribeAddresses -> 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
          ]
      )

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

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

-- | /See:/ 'newDescribeAddressesResponse' smart constructor.
data DescribeAddressesResponse = DescribeAddressesResponse'
  { -- | The Snow device shipping addresses that were created for this account.
    DescribeAddressesResponse -> Maybe [Address]
addresses :: Prelude.Maybe [Address],
    -- | HTTP requests are stateless. If you use the automatically generated
    -- @NextToken@ value in your next @DescribeAddresses@ call, your list of
    -- returned addresses will start from this point in the array.
    DescribeAddressesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    DescribeAddressesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeAddressesResponse -> DescribeAddressesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeAddressesResponse -> DescribeAddressesResponse -> Bool
$c/= :: DescribeAddressesResponse -> DescribeAddressesResponse -> Bool
== :: DescribeAddressesResponse -> DescribeAddressesResponse -> Bool
$c== :: DescribeAddressesResponse -> DescribeAddressesResponse -> Bool
Prelude.Eq, ReadPrec [DescribeAddressesResponse]
ReadPrec DescribeAddressesResponse
Int -> ReadS DescribeAddressesResponse
ReadS [DescribeAddressesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeAddressesResponse]
$creadListPrec :: ReadPrec [DescribeAddressesResponse]
readPrec :: ReadPrec DescribeAddressesResponse
$creadPrec :: ReadPrec DescribeAddressesResponse
readList :: ReadS [DescribeAddressesResponse]
$creadList :: ReadS [DescribeAddressesResponse]
readsPrec :: Int -> ReadS DescribeAddressesResponse
$creadsPrec :: Int -> ReadS DescribeAddressesResponse
Prelude.Read, Int -> DescribeAddressesResponse -> ShowS
[DescribeAddressesResponse] -> ShowS
DescribeAddressesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeAddressesResponse] -> ShowS
$cshowList :: [DescribeAddressesResponse] -> ShowS
show :: DescribeAddressesResponse -> String
$cshow :: DescribeAddressesResponse -> String
showsPrec :: Int -> DescribeAddressesResponse -> ShowS
$cshowsPrec :: Int -> DescribeAddressesResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeAddressesResponse x -> DescribeAddressesResponse
forall x.
DescribeAddressesResponse -> Rep DescribeAddressesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeAddressesResponse x -> DescribeAddressesResponse
$cfrom :: forall x.
DescribeAddressesResponse -> Rep DescribeAddressesResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeAddressesResponse' 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:
--
-- 'addresses', 'describeAddressesResponse_addresses' - The Snow device shipping addresses that were created for this account.
--
-- 'nextToken', 'describeAddressesResponse_nextToken' - HTTP requests are stateless. If you use the automatically generated
-- @NextToken@ value in your next @DescribeAddresses@ call, your list of
-- returned addresses will start from this point in the array.
--
-- 'httpStatus', 'describeAddressesResponse_httpStatus' - The response's http status code.
newDescribeAddressesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeAddressesResponse
newDescribeAddressesResponse :: Int -> DescribeAddressesResponse
newDescribeAddressesResponse Int
pHttpStatus_ =
  DescribeAddressesResponse'
    { $sel:addresses:DescribeAddressesResponse' :: Maybe [Address]
addresses =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeAddressesResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeAddressesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Snow device shipping addresses that were created for this account.
describeAddressesResponse_addresses :: Lens.Lens' DescribeAddressesResponse (Prelude.Maybe [Address])
describeAddressesResponse_addresses :: Lens' DescribeAddressesResponse (Maybe [Address])
describeAddressesResponse_addresses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAddressesResponse' {Maybe [Address]
addresses :: Maybe [Address]
$sel:addresses:DescribeAddressesResponse' :: DescribeAddressesResponse -> Maybe [Address]
addresses} -> Maybe [Address]
addresses) (\s :: DescribeAddressesResponse
s@DescribeAddressesResponse' {} Maybe [Address]
a -> DescribeAddressesResponse
s {$sel:addresses:DescribeAddressesResponse' :: Maybe [Address]
addresses = Maybe [Address]
a} :: DescribeAddressesResponse) 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

-- | HTTP requests are stateless. If you use the automatically generated
-- @NextToken@ value in your next @DescribeAddresses@ call, your list of
-- returned addresses will start from this point in the array.
describeAddressesResponse_nextToken :: Lens.Lens' DescribeAddressesResponse (Prelude.Maybe Prelude.Text)
describeAddressesResponse_nextToken :: Lens' DescribeAddressesResponse (Maybe Text)
describeAddressesResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAddressesResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeAddressesResponse' :: DescribeAddressesResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeAddressesResponse
s@DescribeAddressesResponse' {} Maybe Text
a -> DescribeAddressesResponse
s {$sel:nextToken:DescribeAddressesResponse' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeAddressesResponse)

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

instance Prelude.NFData DescribeAddressesResponse where
  rnf :: DescribeAddressesResponse -> ()
rnf DescribeAddressesResponse' {Int
Maybe [Address]
Maybe Text
httpStatus :: Int
nextToken :: Maybe Text
addresses :: Maybe [Address]
$sel:httpStatus:DescribeAddressesResponse' :: DescribeAddressesResponse -> Int
$sel:nextToken:DescribeAddressesResponse' :: DescribeAddressesResponse -> Maybe Text
$sel:addresses:DescribeAddressesResponse' :: DescribeAddressesResponse -> Maybe [Address]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Address]
addresses
      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 Int
httpStatus