{-# 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.S3.ListBuckets
-- 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 all buckets owned by the authenticated sender of the
-- request. To use this operation, you must have the @s3:ListAllMyBuckets@
-- permission.
module Amazonka.S3.ListBuckets
  ( -- * Creating a Request
    ListBuckets (..),
    newListBuckets,

    -- * Destructuring the Response
    ListBucketsResponse (..),
    newListBucketsResponse,

    -- * Response Lenses
    listBucketsResponse_buckets,
    listBucketsResponse_owner,
    listBucketsResponse_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.S3.Types

-- | /See:/ 'newListBuckets' smart constructor.
data ListBuckets = ListBuckets'
  {
  }
  deriving (ListBuckets -> ListBuckets -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListBuckets -> ListBuckets -> Bool
$c/= :: ListBuckets -> ListBuckets -> Bool
== :: ListBuckets -> ListBuckets -> Bool
$c== :: ListBuckets -> ListBuckets -> Bool
Prelude.Eq, ReadPrec [ListBuckets]
ReadPrec ListBuckets
Int -> ReadS ListBuckets
ReadS [ListBuckets]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListBuckets]
$creadListPrec :: ReadPrec [ListBuckets]
readPrec :: ReadPrec ListBuckets
$creadPrec :: ReadPrec ListBuckets
readList :: ReadS [ListBuckets]
$creadList :: ReadS [ListBuckets]
readsPrec :: Int -> ReadS ListBuckets
$creadsPrec :: Int -> ReadS ListBuckets
Prelude.Read, Int -> ListBuckets -> ShowS
[ListBuckets] -> ShowS
ListBuckets -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListBuckets] -> ShowS
$cshowList :: [ListBuckets] -> ShowS
show :: ListBuckets -> String
$cshow :: ListBuckets -> String
showsPrec :: Int -> ListBuckets -> ShowS
$cshowsPrec :: Int -> ListBuckets -> ShowS
Prelude.Show, forall x. Rep ListBuckets x -> ListBuckets
forall x. ListBuckets -> Rep ListBuckets x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListBuckets x -> ListBuckets
$cfrom :: forall x. ListBuckets -> Rep ListBuckets x
Prelude.Generic)

-- |
-- Create a value of 'ListBuckets' 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.
newListBuckets ::
  ListBuckets
newListBuckets :: ListBuckets
newListBuckets = ListBuckets
ListBuckets'

instance Core.AWSRequest ListBuckets where
  type AWSResponse ListBuckets = ListBucketsResponse
  request :: (Service -> Service) -> ListBuckets -> Request ListBuckets
request Service -> Service
overrides =
    forall a. Request a -> Request a
Request.s3vhost
      forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListBuckets
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListBuckets)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe [Bucket] -> Maybe Owner -> Int -> ListBucketsResponse
ListBucketsResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Buckets"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"Bucket")
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Owner")
            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 ListBuckets where
  hashWithSalt :: Int -> ListBuckets -> Int
hashWithSalt Int
_salt ListBuckets
_ =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ()

instance Prelude.NFData ListBuckets where
  rnf :: ListBuckets -> ()
rnf ListBuckets
_ = ()

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

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

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

-- | /See:/ 'newListBucketsResponse' smart constructor.
data ListBucketsResponse = ListBucketsResponse'
  { -- | The list of buckets owned by the requester.
    ListBucketsResponse -> Maybe [Bucket]
buckets :: Prelude.Maybe [Bucket],
    -- | The owner of the buckets listed.
    ListBucketsResponse -> Maybe Owner
owner :: Prelude.Maybe Owner,
    -- | The response's http status code.
    ListBucketsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListBucketsResponse -> ListBucketsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListBucketsResponse -> ListBucketsResponse -> Bool
$c/= :: ListBucketsResponse -> ListBucketsResponse -> Bool
== :: ListBucketsResponse -> ListBucketsResponse -> Bool
$c== :: ListBucketsResponse -> ListBucketsResponse -> Bool
Prelude.Eq, ReadPrec [ListBucketsResponse]
ReadPrec ListBucketsResponse
Int -> ReadS ListBucketsResponse
ReadS [ListBucketsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListBucketsResponse]
$creadListPrec :: ReadPrec [ListBucketsResponse]
readPrec :: ReadPrec ListBucketsResponse
$creadPrec :: ReadPrec ListBucketsResponse
readList :: ReadS [ListBucketsResponse]
$creadList :: ReadS [ListBucketsResponse]
readsPrec :: Int -> ReadS ListBucketsResponse
$creadsPrec :: Int -> ReadS ListBucketsResponse
Prelude.Read, Int -> ListBucketsResponse -> ShowS
[ListBucketsResponse] -> ShowS
ListBucketsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListBucketsResponse] -> ShowS
$cshowList :: [ListBucketsResponse] -> ShowS
show :: ListBucketsResponse -> String
$cshow :: ListBucketsResponse -> String
showsPrec :: Int -> ListBucketsResponse -> ShowS
$cshowsPrec :: Int -> ListBucketsResponse -> ShowS
Prelude.Show, forall x. Rep ListBucketsResponse x -> ListBucketsResponse
forall x. ListBucketsResponse -> Rep ListBucketsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListBucketsResponse x -> ListBucketsResponse
$cfrom :: forall x. ListBucketsResponse -> Rep ListBucketsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListBucketsResponse' 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:
--
-- 'buckets', 'listBucketsResponse_buckets' - The list of buckets owned by the requester.
--
-- 'owner', 'listBucketsResponse_owner' - The owner of the buckets listed.
--
-- 'httpStatus', 'listBucketsResponse_httpStatus' - The response's http status code.
newListBucketsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListBucketsResponse
newListBucketsResponse :: Int -> ListBucketsResponse
newListBucketsResponse Int
pHttpStatus_ =
  ListBucketsResponse'
    { $sel:buckets:ListBucketsResponse' :: Maybe [Bucket]
buckets = forall a. Maybe a
Prelude.Nothing,
      $sel:owner:ListBucketsResponse' :: Maybe Owner
owner = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListBucketsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The list of buckets owned by the requester.
listBucketsResponse_buckets :: Lens.Lens' ListBucketsResponse (Prelude.Maybe [Bucket])
listBucketsResponse_buckets :: Lens' ListBucketsResponse (Maybe [Bucket])
listBucketsResponse_buckets = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListBucketsResponse' {Maybe [Bucket]
buckets :: Maybe [Bucket]
$sel:buckets:ListBucketsResponse' :: ListBucketsResponse -> Maybe [Bucket]
buckets} -> Maybe [Bucket]
buckets) (\s :: ListBucketsResponse
s@ListBucketsResponse' {} Maybe [Bucket]
a -> ListBucketsResponse
s {$sel:buckets:ListBucketsResponse' :: Maybe [Bucket]
buckets = Maybe [Bucket]
a} :: ListBucketsResponse) 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 owner of the buckets listed.
listBucketsResponse_owner :: Lens.Lens' ListBucketsResponse (Prelude.Maybe Owner)
listBucketsResponse_owner :: Lens' ListBucketsResponse (Maybe Owner)
listBucketsResponse_owner = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListBucketsResponse' {Maybe Owner
owner :: Maybe Owner
$sel:owner:ListBucketsResponse' :: ListBucketsResponse -> Maybe Owner
owner} -> Maybe Owner
owner) (\s :: ListBucketsResponse
s@ListBucketsResponse' {} Maybe Owner
a -> ListBucketsResponse
s {$sel:owner:ListBucketsResponse' :: Maybe Owner
owner = Maybe Owner
a} :: ListBucketsResponse)

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

instance Prelude.NFData ListBucketsResponse where
  rnf :: ListBucketsResponse -> ()
rnf ListBucketsResponse' {Int
Maybe [Bucket]
Maybe Owner
httpStatus :: Int
owner :: Maybe Owner
buckets :: Maybe [Bucket]
$sel:httpStatus:ListBucketsResponse' :: ListBucketsResponse -> Int
$sel:owner:ListBucketsResponse' :: ListBucketsResponse -> Maybe Owner
$sel:buckets:ListBucketsResponse' :: ListBucketsResponse -> Maybe [Bucket]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Bucket]
buckets
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Owner
owner
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus