{-# 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.ListObjectVersions
-- 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 metadata about all versions of the objects in a bucket. You can
-- also use request parameters as selection criteria to return metadata
-- about a subset of all the object versions.
--
-- To use this operation, you must have permissions to perform the
-- @s3:ListBucketVersions@ action. Be aware of the name difference.
--
-- A 200 OK response can contain valid or invalid XML. Make sure to design
-- your application to parse the contents of the response and handle it
-- appropriately.
--
-- To use this operation, you must have READ access to the bucket.
--
-- This action is not supported by Amazon S3 on Outposts.
--
-- The following operations are related to @ListObjectVersions@:
--
-- -   <https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html ListObjectsV2>
--
-- -   <https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html GetObject>
--
-- -   <https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html PutObject>
--
-- -   <https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObject.html DeleteObject>
--
-- This operation returns paginated results.
module Amazonka.S3.ListObjectVersions
  ( -- * Creating a Request
    ListObjectVersions (..),
    newListObjectVersions,

    -- * Request Lenses
    listObjectVersions_delimiter,
    listObjectVersions_encodingType,
    listObjectVersions_expectedBucketOwner,
    listObjectVersions_keyMarker,
    listObjectVersions_maxKeys,
    listObjectVersions_prefix,
    listObjectVersions_versionIdMarker,
    listObjectVersions_bucket,

    -- * Destructuring the Response
    ListObjectVersionsResponse (..),
    newListObjectVersionsResponse,

    -- * Response Lenses
    listObjectVersionsResponse_commonPrefixes,
    listObjectVersionsResponse_deleteMarkers,
    listObjectVersionsResponse_delimiter,
    listObjectVersionsResponse_encodingType,
    listObjectVersionsResponse_isTruncated,
    listObjectVersionsResponse_keyMarker,
    listObjectVersionsResponse_maxKeys,
    listObjectVersionsResponse_name,
    listObjectVersionsResponse_nextKeyMarker,
    listObjectVersionsResponse_nextVersionIdMarker,
    listObjectVersionsResponse_prefix,
    listObjectVersionsResponse_versionIdMarker,
    listObjectVersionsResponse_versions,
    listObjectVersionsResponse_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:/ 'newListObjectVersions' smart constructor.
data ListObjectVersions = ListObjectVersions'
  { -- | A delimiter is a character that you specify to group keys. All keys that
    -- contain the same string between the @prefix@ and the first occurrence of
    -- the delimiter are grouped under a single result element in
    -- CommonPrefixes. These groups are counted as one result against the
    -- max-keys limitation. These keys are not returned elsewhere in the
    -- response.
    ListObjectVersions -> Maybe Delimiter
delimiter :: Prelude.Maybe Delimiter,
    ListObjectVersions -> Maybe EncodingType
encodingType :: Prelude.Maybe EncodingType,
    -- | The account ID of the expected bucket owner. If the bucket is owned by a
    -- different account, the request fails with the HTTP status code
    -- @403 Forbidden@ (access denied).
    ListObjectVersions -> Maybe Text
expectedBucketOwner :: Prelude.Maybe Prelude.Text,
    -- | Specifies the key to start with when listing objects in a bucket.
    ListObjectVersions -> Maybe Text
keyMarker :: Prelude.Maybe Prelude.Text,
    -- | Sets the maximum number of keys returned in the response. By default the
    -- action returns up to 1,000 key names. The response might contain fewer
    -- keys but will never contain more. If additional keys satisfy the search
    -- criteria, but were not returned because max-keys was exceeded, the
    -- response contains \<isTruncated>true\<\/isTruncated>. To return the
    -- additional keys, see key-marker and version-id-marker.
    ListObjectVersions -> Maybe Int
maxKeys :: Prelude.Maybe Prelude.Int,
    -- | Use this parameter to select only those keys that begin with the
    -- specified prefix. You can use prefixes to separate a bucket into
    -- different groupings of keys. (You can think of using prefix to make
    -- groups in the same way you\'d use a folder in a file system.) You can
    -- use prefix with delimiter to roll up numerous objects into a single
    -- result under CommonPrefixes.
    ListObjectVersions -> Maybe Text
prefix :: Prelude.Maybe Prelude.Text,
    -- | Specifies the object version you want to start listing from.
    ListObjectVersions -> Maybe Text
versionIdMarker :: Prelude.Maybe Prelude.Text,
    -- | The bucket name that contains the objects.
    ListObjectVersions -> BucketName
bucket :: BucketName
  }
  deriving (ListObjectVersions -> ListObjectVersions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListObjectVersions -> ListObjectVersions -> Bool
$c/= :: ListObjectVersions -> ListObjectVersions -> Bool
== :: ListObjectVersions -> ListObjectVersions -> Bool
$c== :: ListObjectVersions -> ListObjectVersions -> Bool
Prelude.Eq, ReadPrec [ListObjectVersions]
ReadPrec ListObjectVersions
Int -> ReadS ListObjectVersions
ReadS [ListObjectVersions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListObjectVersions]
$creadListPrec :: ReadPrec [ListObjectVersions]
readPrec :: ReadPrec ListObjectVersions
$creadPrec :: ReadPrec ListObjectVersions
readList :: ReadS [ListObjectVersions]
$creadList :: ReadS [ListObjectVersions]
readsPrec :: Int -> ReadS ListObjectVersions
$creadsPrec :: Int -> ReadS ListObjectVersions
Prelude.Read, Int -> ListObjectVersions -> ShowS
[ListObjectVersions] -> ShowS
ListObjectVersions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListObjectVersions] -> ShowS
$cshowList :: [ListObjectVersions] -> ShowS
show :: ListObjectVersions -> String
$cshow :: ListObjectVersions -> String
showsPrec :: Int -> ListObjectVersions -> ShowS
$cshowsPrec :: Int -> ListObjectVersions -> ShowS
Prelude.Show, forall x. Rep ListObjectVersions x -> ListObjectVersions
forall x. ListObjectVersions -> Rep ListObjectVersions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListObjectVersions x -> ListObjectVersions
$cfrom :: forall x. ListObjectVersions -> Rep ListObjectVersions x
Prelude.Generic)

-- |
-- Create a value of 'ListObjectVersions' 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:
--
-- 'delimiter', 'listObjectVersions_delimiter' - A delimiter is a character that you specify to group keys. All keys that
-- contain the same string between the @prefix@ and the first occurrence of
-- the delimiter are grouped under a single result element in
-- CommonPrefixes. These groups are counted as one result against the
-- max-keys limitation. These keys are not returned elsewhere in the
-- response.
--
-- 'encodingType', 'listObjectVersions_encodingType' - Undocumented member.
--
-- 'expectedBucketOwner', 'listObjectVersions_expectedBucketOwner' - The account ID of the expected bucket owner. If the bucket is owned by a
-- different account, the request fails with the HTTP status code
-- @403 Forbidden@ (access denied).
--
-- 'keyMarker', 'listObjectVersions_keyMarker' - Specifies the key to start with when listing objects in a bucket.
--
-- 'maxKeys', 'listObjectVersions_maxKeys' - Sets the maximum number of keys returned in the response. By default the
-- action returns up to 1,000 key names. The response might contain fewer
-- keys but will never contain more. If additional keys satisfy the search
-- criteria, but were not returned because max-keys was exceeded, the
-- response contains \<isTruncated>true\<\/isTruncated>. To return the
-- additional keys, see key-marker and version-id-marker.
--
-- 'prefix', 'listObjectVersions_prefix' - Use this parameter to select only those keys that begin with the
-- specified prefix. You can use prefixes to separate a bucket into
-- different groupings of keys. (You can think of using prefix to make
-- groups in the same way you\'d use a folder in a file system.) You can
-- use prefix with delimiter to roll up numerous objects into a single
-- result under CommonPrefixes.
--
-- 'versionIdMarker', 'listObjectVersions_versionIdMarker' - Specifies the object version you want to start listing from.
--
-- 'bucket', 'listObjectVersions_bucket' - The bucket name that contains the objects.
newListObjectVersions ::
  -- | 'bucket'
  BucketName ->
  ListObjectVersions
newListObjectVersions :: BucketName -> ListObjectVersions
newListObjectVersions BucketName
pBucket_ =
  ListObjectVersions'
    { $sel:delimiter:ListObjectVersions' :: Maybe Delimiter
delimiter = forall a. Maybe a
Prelude.Nothing,
      $sel:encodingType:ListObjectVersions' :: Maybe EncodingType
encodingType = forall a. Maybe a
Prelude.Nothing,
      $sel:expectedBucketOwner:ListObjectVersions' :: Maybe Text
expectedBucketOwner = forall a. Maybe a
Prelude.Nothing,
      $sel:keyMarker:ListObjectVersions' :: Maybe Text
keyMarker = forall a. Maybe a
Prelude.Nothing,
      $sel:maxKeys:ListObjectVersions' :: Maybe Int
maxKeys = forall a. Maybe a
Prelude.Nothing,
      $sel:prefix:ListObjectVersions' :: Maybe Text
prefix = forall a. Maybe a
Prelude.Nothing,
      $sel:versionIdMarker:ListObjectVersions' :: Maybe Text
versionIdMarker = forall a. Maybe a
Prelude.Nothing,
      $sel:bucket:ListObjectVersions' :: BucketName
bucket = BucketName
pBucket_
    }

-- | A delimiter is a character that you specify to group keys. All keys that
-- contain the same string between the @prefix@ and the first occurrence of
-- the delimiter are grouped under a single result element in
-- CommonPrefixes. These groups are counted as one result against the
-- max-keys limitation. These keys are not returned elsewhere in the
-- response.
listObjectVersions_delimiter :: Lens.Lens' ListObjectVersions (Prelude.Maybe Delimiter)
listObjectVersions_delimiter :: Lens' ListObjectVersions (Maybe Delimiter)
listObjectVersions_delimiter = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersions' {Maybe Delimiter
delimiter :: Maybe Delimiter
$sel:delimiter:ListObjectVersions' :: ListObjectVersions -> Maybe Delimiter
delimiter} -> Maybe Delimiter
delimiter) (\s :: ListObjectVersions
s@ListObjectVersions' {} Maybe Delimiter
a -> ListObjectVersions
s {$sel:delimiter:ListObjectVersions' :: Maybe Delimiter
delimiter = Maybe Delimiter
a} :: ListObjectVersions)

-- | Undocumented member.
listObjectVersions_encodingType :: Lens.Lens' ListObjectVersions (Prelude.Maybe EncodingType)
listObjectVersions_encodingType :: Lens' ListObjectVersions (Maybe EncodingType)
listObjectVersions_encodingType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersions' {Maybe EncodingType
encodingType :: Maybe EncodingType
$sel:encodingType:ListObjectVersions' :: ListObjectVersions -> Maybe EncodingType
encodingType} -> Maybe EncodingType
encodingType) (\s :: ListObjectVersions
s@ListObjectVersions' {} Maybe EncodingType
a -> ListObjectVersions
s {$sel:encodingType:ListObjectVersions' :: Maybe EncodingType
encodingType = Maybe EncodingType
a} :: ListObjectVersions)

-- | The account ID of the expected bucket owner. If the bucket is owned by a
-- different account, the request fails with the HTTP status code
-- @403 Forbidden@ (access denied).
listObjectVersions_expectedBucketOwner :: Lens.Lens' ListObjectVersions (Prelude.Maybe Prelude.Text)
listObjectVersions_expectedBucketOwner :: Lens' ListObjectVersions (Maybe Text)
listObjectVersions_expectedBucketOwner = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersions' {Maybe Text
expectedBucketOwner :: Maybe Text
$sel:expectedBucketOwner:ListObjectVersions' :: ListObjectVersions -> Maybe Text
expectedBucketOwner} -> Maybe Text
expectedBucketOwner) (\s :: ListObjectVersions
s@ListObjectVersions' {} Maybe Text
a -> ListObjectVersions
s {$sel:expectedBucketOwner:ListObjectVersions' :: Maybe Text
expectedBucketOwner = Maybe Text
a} :: ListObjectVersions)

-- | Specifies the key to start with when listing objects in a bucket.
listObjectVersions_keyMarker :: Lens.Lens' ListObjectVersions (Prelude.Maybe Prelude.Text)
listObjectVersions_keyMarker :: Lens' ListObjectVersions (Maybe Text)
listObjectVersions_keyMarker = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersions' {Maybe Text
keyMarker :: Maybe Text
$sel:keyMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
keyMarker} -> Maybe Text
keyMarker) (\s :: ListObjectVersions
s@ListObjectVersions' {} Maybe Text
a -> ListObjectVersions
s {$sel:keyMarker:ListObjectVersions' :: Maybe Text
keyMarker = Maybe Text
a} :: ListObjectVersions)

-- | Sets the maximum number of keys returned in the response. By default the
-- action returns up to 1,000 key names. The response might contain fewer
-- keys but will never contain more. If additional keys satisfy the search
-- criteria, but were not returned because max-keys was exceeded, the
-- response contains \<isTruncated>true\<\/isTruncated>. To return the
-- additional keys, see key-marker and version-id-marker.
listObjectVersions_maxKeys :: Lens.Lens' ListObjectVersions (Prelude.Maybe Prelude.Int)
listObjectVersions_maxKeys :: Lens' ListObjectVersions (Maybe Int)
listObjectVersions_maxKeys = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersions' {Maybe Int
maxKeys :: Maybe Int
$sel:maxKeys:ListObjectVersions' :: ListObjectVersions -> Maybe Int
maxKeys} -> Maybe Int
maxKeys) (\s :: ListObjectVersions
s@ListObjectVersions' {} Maybe Int
a -> ListObjectVersions
s {$sel:maxKeys:ListObjectVersions' :: Maybe Int
maxKeys = Maybe Int
a} :: ListObjectVersions)

-- | Use this parameter to select only those keys that begin with the
-- specified prefix. You can use prefixes to separate a bucket into
-- different groupings of keys. (You can think of using prefix to make
-- groups in the same way you\'d use a folder in a file system.) You can
-- use prefix with delimiter to roll up numerous objects into a single
-- result under CommonPrefixes.
listObjectVersions_prefix :: Lens.Lens' ListObjectVersions (Prelude.Maybe Prelude.Text)
listObjectVersions_prefix :: Lens' ListObjectVersions (Maybe Text)
listObjectVersions_prefix = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersions' {Maybe Text
prefix :: Maybe Text
$sel:prefix:ListObjectVersions' :: ListObjectVersions -> Maybe Text
prefix} -> Maybe Text
prefix) (\s :: ListObjectVersions
s@ListObjectVersions' {} Maybe Text
a -> ListObjectVersions
s {$sel:prefix:ListObjectVersions' :: Maybe Text
prefix = Maybe Text
a} :: ListObjectVersions)

-- | Specifies the object version you want to start listing from.
listObjectVersions_versionIdMarker :: Lens.Lens' ListObjectVersions (Prelude.Maybe Prelude.Text)
listObjectVersions_versionIdMarker :: Lens' ListObjectVersions (Maybe Text)
listObjectVersions_versionIdMarker = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersions' {Maybe Text
versionIdMarker :: Maybe Text
$sel:versionIdMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
versionIdMarker} -> Maybe Text
versionIdMarker) (\s :: ListObjectVersions
s@ListObjectVersions' {} Maybe Text
a -> ListObjectVersions
s {$sel:versionIdMarker:ListObjectVersions' :: Maybe Text
versionIdMarker = Maybe Text
a} :: ListObjectVersions)

-- | The bucket name that contains the objects.
listObjectVersions_bucket :: Lens.Lens' ListObjectVersions BucketName
listObjectVersions_bucket :: Lens' ListObjectVersions BucketName
listObjectVersions_bucket = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersions' {BucketName
bucket :: BucketName
$sel:bucket:ListObjectVersions' :: ListObjectVersions -> BucketName
bucket} -> BucketName
bucket) (\s :: ListObjectVersions
s@ListObjectVersions' {} BucketName
a -> ListObjectVersions
s {$sel:bucket:ListObjectVersions' :: BucketName
bucket = BucketName
a} :: ListObjectVersions)

instance Core.AWSPager ListObjectVersions where
  page :: ListObjectVersions
-> AWSResponse ListObjectVersions -> Maybe ListObjectVersions
page ListObjectVersions
rq AWSResponse ListObjectVersions
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListObjectVersions
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListObjectVersionsResponse (Maybe Bool)
listObjectVersionsResponse_isTruncated
            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. Maybe a -> Bool
Prelude.isNothing
        ( AWSResponse ListObjectVersions
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListObjectVersionsResponse (Maybe Text)
listObjectVersionsResponse_nextKeyMarker
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        )
        Bool -> Bool -> Bool
Prelude.&& forall a. Maybe a -> Bool
Prelude.isNothing
          ( AWSResponse ListObjectVersions
rs
              forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListObjectVersionsResponse (Maybe Text)
listObjectVersionsResponse_nextVersionIdMarker
              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.$ ListObjectVersions
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListObjectVersions (Maybe Text)
listObjectVersions_keyMarker
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListObjectVersions
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListObjectVersionsResponse (Maybe Text)
listObjectVersionsResponse_nextKeyMarker
          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 b. a -> (a -> b) -> b
Prelude.& Lens' ListObjectVersions (Maybe Text)
listObjectVersions_versionIdMarker
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListObjectVersions
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListObjectVersionsResponse (Maybe Text)
listObjectVersionsResponse_nextVersionIdMarker
          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 ListObjectVersions where
  type
    AWSResponse ListObjectVersions =
      ListObjectVersionsResponse
  request :: (Service -> Service)
-> ListObjectVersions -> Request ListObjectVersions
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 ListObjectVersions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListObjectVersions)))
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 [CommonPrefix]
-> Maybe [DeleteMarkerEntry]
-> Maybe Delimiter
-> Maybe EncodingType
-> Maybe Bool
-> Maybe Text
-> Maybe Int
-> Maybe BucketName
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe [ObjectVersion]
-> Int
-> ListObjectVersionsResponse
ListObjectVersionsResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f 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
"CommonPrefixes") [Node]
x)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f 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
"DeleteMarker") [Node]
x)
            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
"Delimiter")
            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
"EncodingType")
            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
"IsTruncated")
            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
"KeyMarker")
            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
"MaxKeys")
            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
"Name")
            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
"NextKeyMarker")
            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
"NextVersionIdMarker")
            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
"Prefix")
            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
"VersionIdMarker")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f 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
"Version") [Node]
x)
            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 ListObjectVersions where
  hashWithSalt :: Int -> ListObjectVersions -> Int
hashWithSalt Int
_salt ListObjectVersions' {Maybe Delimiter
Maybe Int
Maybe Text
Maybe EncodingType
BucketName
bucket :: BucketName
versionIdMarker :: Maybe Text
prefix :: Maybe Text
maxKeys :: Maybe Int
keyMarker :: Maybe Text
expectedBucketOwner :: Maybe Text
encodingType :: Maybe EncodingType
delimiter :: Maybe Delimiter
$sel:bucket:ListObjectVersions' :: ListObjectVersions -> BucketName
$sel:versionIdMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:prefix:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:maxKeys:ListObjectVersions' :: ListObjectVersions -> Maybe Int
$sel:keyMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:expectedBucketOwner:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:encodingType:ListObjectVersions' :: ListObjectVersions -> Maybe EncodingType
$sel:delimiter:ListObjectVersions' :: ListObjectVersions -> Maybe Delimiter
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Delimiter
delimiter
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EncodingType
encodingType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
expectedBucketOwner
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
keyMarker
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
maxKeys
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
prefix
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
versionIdMarker
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` BucketName
bucket

instance Prelude.NFData ListObjectVersions where
  rnf :: ListObjectVersions -> ()
rnf ListObjectVersions' {Maybe Delimiter
Maybe Int
Maybe Text
Maybe EncodingType
BucketName
bucket :: BucketName
versionIdMarker :: Maybe Text
prefix :: Maybe Text
maxKeys :: Maybe Int
keyMarker :: Maybe Text
expectedBucketOwner :: Maybe Text
encodingType :: Maybe EncodingType
delimiter :: Maybe Delimiter
$sel:bucket:ListObjectVersions' :: ListObjectVersions -> BucketName
$sel:versionIdMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:prefix:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:maxKeys:ListObjectVersions' :: ListObjectVersions -> Maybe Int
$sel:keyMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:expectedBucketOwner:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:encodingType:ListObjectVersions' :: ListObjectVersions -> Maybe EncodingType
$sel:delimiter:ListObjectVersions' :: ListObjectVersions -> Maybe Delimiter
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Delimiter
delimiter
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EncodingType
encodingType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
expectedBucketOwner
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
keyMarker
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
maxKeys
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
prefix
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
versionIdMarker
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf BucketName
bucket

instance Data.ToHeaders ListObjectVersions where
  toHeaders :: ListObjectVersions -> ResponseHeaders
toHeaders ListObjectVersions' {Maybe Delimiter
Maybe Int
Maybe Text
Maybe EncodingType
BucketName
bucket :: BucketName
versionIdMarker :: Maybe Text
prefix :: Maybe Text
maxKeys :: Maybe Int
keyMarker :: Maybe Text
expectedBucketOwner :: Maybe Text
encodingType :: Maybe EncodingType
delimiter :: Maybe Delimiter
$sel:bucket:ListObjectVersions' :: ListObjectVersions -> BucketName
$sel:versionIdMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:prefix:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:maxKeys:ListObjectVersions' :: ListObjectVersions -> Maybe Int
$sel:keyMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:expectedBucketOwner:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:encodingType:ListObjectVersions' :: ListObjectVersions -> Maybe EncodingType
$sel:delimiter:ListObjectVersions' :: ListObjectVersions -> Maybe Delimiter
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ HeaderName
"x-amz-expected-bucket-owner"
          forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# Maybe Text
expectedBucketOwner
      ]

instance Data.ToPath ListObjectVersions where
  toPath :: ListObjectVersions -> ByteString
toPath ListObjectVersions' {Maybe Delimiter
Maybe Int
Maybe Text
Maybe EncodingType
BucketName
bucket :: BucketName
versionIdMarker :: Maybe Text
prefix :: Maybe Text
maxKeys :: Maybe Int
keyMarker :: Maybe Text
expectedBucketOwner :: Maybe Text
encodingType :: Maybe EncodingType
delimiter :: Maybe Delimiter
$sel:bucket:ListObjectVersions' :: ListObjectVersions -> BucketName
$sel:versionIdMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:prefix:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:maxKeys:ListObjectVersions' :: ListObjectVersions -> Maybe Int
$sel:keyMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:expectedBucketOwner:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:encodingType:ListObjectVersions' :: ListObjectVersions -> Maybe EncodingType
$sel:delimiter:ListObjectVersions' :: ListObjectVersions -> Maybe Delimiter
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat [ByteString
"/", forall a. ToByteString a => a -> ByteString
Data.toBS BucketName
bucket]

instance Data.ToQuery ListObjectVersions where
  toQuery :: ListObjectVersions -> QueryString
toQuery ListObjectVersions' {Maybe Delimiter
Maybe Int
Maybe Text
Maybe EncodingType
BucketName
bucket :: BucketName
versionIdMarker :: Maybe Text
prefix :: Maybe Text
maxKeys :: Maybe Int
keyMarker :: Maybe Text
expectedBucketOwner :: Maybe Text
encodingType :: Maybe EncodingType
delimiter :: Maybe Delimiter
$sel:bucket:ListObjectVersions' :: ListObjectVersions -> BucketName
$sel:versionIdMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:prefix:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:maxKeys:ListObjectVersions' :: ListObjectVersions -> Maybe Int
$sel:keyMarker:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:expectedBucketOwner:ListObjectVersions' :: ListObjectVersions -> Maybe Text
$sel:encodingType:ListObjectVersions' :: ListObjectVersions -> Maybe EncodingType
$sel:delimiter:ListObjectVersions' :: ListObjectVersions -> Maybe Delimiter
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"delimiter" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Delimiter
delimiter,
        ByteString
"encoding-type" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe EncodingType
encodingType,
        ByteString
"key-marker" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
keyMarker,
        ByteString
"max-keys" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
maxKeys,
        ByteString
"prefix" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
prefix,
        ByteString
"version-id-marker" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
versionIdMarker,
        QueryString
"versions"
      ]

-- | /See:/ 'newListObjectVersionsResponse' smart constructor.
data ListObjectVersionsResponse = ListObjectVersionsResponse'
  { -- | All of the keys rolled up into a common prefix count as a single return
    -- when calculating the number of returns.
    ListObjectVersionsResponse -> Maybe [CommonPrefix]
commonPrefixes :: Prelude.Maybe [CommonPrefix],
    -- | Container for an object that is a delete marker.
    ListObjectVersionsResponse -> Maybe [DeleteMarkerEntry]
deleteMarkers :: Prelude.Maybe [DeleteMarkerEntry],
    -- | The delimiter grouping the included keys. A delimiter is a character
    -- that you specify to group keys. All keys that contain the same string
    -- between the prefix and the first occurrence of the delimiter are grouped
    -- under a single result element in @CommonPrefixes@. These groups are
    -- counted as one result against the max-keys limitation. These keys are
    -- not returned elsewhere in the response.
    ListObjectVersionsResponse -> Maybe Delimiter
delimiter :: Prelude.Maybe Delimiter,
    -- | Encoding type used by Amazon S3 to encode object key names in the XML
    -- response.
    --
    -- If you specify encoding-type request parameter, Amazon S3 includes this
    -- element in the response, and returns encoded key name values in the
    -- following response elements:
    --
    -- @KeyMarker, NextKeyMarker, Prefix, Key@, and @Delimiter@.
    ListObjectVersionsResponse -> Maybe EncodingType
encodingType :: Prelude.Maybe EncodingType,
    -- | A flag that indicates whether Amazon S3 returned all of the results that
    -- satisfied the search criteria. If your results were truncated, you can
    -- make a follow-up paginated request using the NextKeyMarker and
    -- NextVersionIdMarker response parameters as a starting place in another
    -- request to return the rest of the results.
    ListObjectVersionsResponse -> Maybe Bool
isTruncated :: Prelude.Maybe Prelude.Bool,
    -- | Marks the last key returned in a truncated response.
    ListObjectVersionsResponse -> Maybe Text
keyMarker :: Prelude.Maybe Prelude.Text,
    -- | Specifies the maximum number of objects to return.
    ListObjectVersionsResponse -> Maybe Int
maxKeys :: Prelude.Maybe Prelude.Int,
    -- | The bucket name.
    ListObjectVersionsResponse -> Maybe BucketName
name :: Prelude.Maybe BucketName,
    -- | When the number of responses exceeds the value of @MaxKeys@,
    -- @NextKeyMarker@ specifies the first key not returned that satisfies the
    -- search criteria. Use this value for the key-marker request parameter in
    -- a subsequent request.
    ListObjectVersionsResponse -> Maybe Text
nextKeyMarker :: Prelude.Maybe Prelude.Text,
    -- | When the number of responses exceeds the value of @MaxKeys@,
    -- @NextVersionIdMarker@ specifies the first object version not returned
    -- that satisfies the search criteria. Use this value for the
    -- version-id-marker request parameter in a subsequent request.
    ListObjectVersionsResponse -> Maybe Text
nextVersionIdMarker :: Prelude.Maybe Prelude.Text,
    -- | Selects objects that start with the value supplied by this parameter.
    ListObjectVersionsResponse -> Maybe Text
prefix :: Prelude.Maybe Prelude.Text,
    -- | Marks the last version of the key returned in a truncated response.
    ListObjectVersionsResponse -> Maybe Text
versionIdMarker :: Prelude.Maybe Prelude.Text,
    -- | Container for version information.
    ListObjectVersionsResponse -> Maybe [ObjectVersion]
versions :: Prelude.Maybe [ObjectVersion],
    -- | The response's http status code.
    ListObjectVersionsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListObjectVersionsResponse -> ListObjectVersionsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListObjectVersionsResponse -> ListObjectVersionsResponse -> Bool
$c/= :: ListObjectVersionsResponse -> ListObjectVersionsResponse -> Bool
== :: ListObjectVersionsResponse -> ListObjectVersionsResponse -> Bool
$c== :: ListObjectVersionsResponse -> ListObjectVersionsResponse -> Bool
Prelude.Eq, ReadPrec [ListObjectVersionsResponse]
ReadPrec ListObjectVersionsResponse
Int -> ReadS ListObjectVersionsResponse
ReadS [ListObjectVersionsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListObjectVersionsResponse]
$creadListPrec :: ReadPrec [ListObjectVersionsResponse]
readPrec :: ReadPrec ListObjectVersionsResponse
$creadPrec :: ReadPrec ListObjectVersionsResponse
readList :: ReadS [ListObjectVersionsResponse]
$creadList :: ReadS [ListObjectVersionsResponse]
readsPrec :: Int -> ReadS ListObjectVersionsResponse
$creadsPrec :: Int -> ReadS ListObjectVersionsResponse
Prelude.Read, Int -> ListObjectVersionsResponse -> ShowS
[ListObjectVersionsResponse] -> ShowS
ListObjectVersionsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListObjectVersionsResponse] -> ShowS
$cshowList :: [ListObjectVersionsResponse] -> ShowS
show :: ListObjectVersionsResponse -> String
$cshow :: ListObjectVersionsResponse -> String
showsPrec :: Int -> ListObjectVersionsResponse -> ShowS
$cshowsPrec :: Int -> ListObjectVersionsResponse -> ShowS
Prelude.Show, forall x.
Rep ListObjectVersionsResponse x -> ListObjectVersionsResponse
forall x.
ListObjectVersionsResponse -> Rep ListObjectVersionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListObjectVersionsResponse x -> ListObjectVersionsResponse
$cfrom :: forall x.
ListObjectVersionsResponse -> Rep ListObjectVersionsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListObjectVersionsResponse' 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:
--
-- 'commonPrefixes', 'listObjectVersionsResponse_commonPrefixes' - All of the keys rolled up into a common prefix count as a single return
-- when calculating the number of returns.
--
-- 'deleteMarkers', 'listObjectVersionsResponse_deleteMarkers' - Container for an object that is a delete marker.
--
-- 'delimiter', 'listObjectVersionsResponse_delimiter' - The delimiter grouping the included keys. A delimiter is a character
-- that you specify to group keys. All keys that contain the same string
-- between the prefix and the first occurrence of the delimiter are grouped
-- under a single result element in @CommonPrefixes@. These groups are
-- counted as one result against the max-keys limitation. These keys are
-- not returned elsewhere in the response.
--
-- 'encodingType', 'listObjectVersionsResponse_encodingType' - Encoding type used by Amazon S3 to encode object key names in the XML
-- response.
--
-- If you specify encoding-type request parameter, Amazon S3 includes this
-- element in the response, and returns encoded key name values in the
-- following response elements:
--
-- @KeyMarker, NextKeyMarker, Prefix, Key@, and @Delimiter@.
--
-- 'isTruncated', 'listObjectVersionsResponse_isTruncated' - A flag that indicates whether Amazon S3 returned all of the results that
-- satisfied the search criteria. If your results were truncated, you can
-- make a follow-up paginated request using the NextKeyMarker and
-- NextVersionIdMarker response parameters as a starting place in another
-- request to return the rest of the results.
--
-- 'keyMarker', 'listObjectVersionsResponse_keyMarker' - Marks the last key returned in a truncated response.
--
-- 'maxKeys', 'listObjectVersionsResponse_maxKeys' - Specifies the maximum number of objects to return.
--
-- 'name', 'listObjectVersionsResponse_name' - The bucket name.
--
-- 'nextKeyMarker', 'listObjectVersionsResponse_nextKeyMarker' - When the number of responses exceeds the value of @MaxKeys@,
-- @NextKeyMarker@ specifies the first key not returned that satisfies the
-- search criteria. Use this value for the key-marker request parameter in
-- a subsequent request.
--
-- 'nextVersionIdMarker', 'listObjectVersionsResponse_nextVersionIdMarker' - When the number of responses exceeds the value of @MaxKeys@,
-- @NextVersionIdMarker@ specifies the first object version not returned
-- that satisfies the search criteria. Use this value for the
-- version-id-marker request parameter in a subsequent request.
--
-- 'prefix', 'listObjectVersionsResponse_prefix' - Selects objects that start with the value supplied by this parameter.
--
-- 'versionIdMarker', 'listObjectVersionsResponse_versionIdMarker' - Marks the last version of the key returned in a truncated response.
--
-- 'versions', 'listObjectVersionsResponse_versions' - Container for version information.
--
-- 'httpStatus', 'listObjectVersionsResponse_httpStatus' - The response's http status code.
newListObjectVersionsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListObjectVersionsResponse
newListObjectVersionsResponse :: Int -> ListObjectVersionsResponse
newListObjectVersionsResponse Int
pHttpStatus_ =
  ListObjectVersionsResponse'
    { $sel:commonPrefixes:ListObjectVersionsResponse' :: Maybe [CommonPrefix]
commonPrefixes =
        forall a. Maybe a
Prelude.Nothing,
      $sel:deleteMarkers:ListObjectVersionsResponse' :: Maybe [DeleteMarkerEntry]
deleteMarkers = forall a. Maybe a
Prelude.Nothing,
      $sel:delimiter:ListObjectVersionsResponse' :: Maybe Delimiter
delimiter = forall a. Maybe a
Prelude.Nothing,
      $sel:encodingType:ListObjectVersionsResponse' :: Maybe EncodingType
encodingType = forall a. Maybe a
Prelude.Nothing,
      $sel:isTruncated:ListObjectVersionsResponse' :: Maybe Bool
isTruncated = forall a. Maybe a
Prelude.Nothing,
      $sel:keyMarker:ListObjectVersionsResponse' :: Maybe Text
keyMarker = forall a. Maybe a
Prelude.Nothing,
      $sel:maxKeys:ListObjectVersionsResponse' :: Maybe Int
maxKeys = forall a. Maybe a
Prelude.Nothing,
      $sel:name:ListObjectVersionsResponse' :: Maybe BucketName
name = forall a. Maybe a
Prelude.Nothing,
      $sel:nextKeyMarker:ListObjectVersionsResponse' :: Maybe Text
nextKeyMarker = forall a. Maybe a
Prelude.Nothing,
      $sel:nextVersionIdMarker:ListObjectVersionsResponse' :: Maybe Text
nextVersionIdMarker = forall a. Maybe a
Prelude.Nothing,
      $sel:prefix:ListObjectVersionsResponse' :: Maybe Text
prefix = forall a. Maybe a
Prelude.Nothing,
      $sel:versionIdMarker:ListObjectVersionsResponse' :: Maybe Text
versionIdMarker = forall a. Maybe a
Prelude.Nothing,
      $sel:versions:ListObjectVersionsResponse' :: Maybe [ObjectVersion]
versions = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListObjectVersionsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | All of the keys rolled up into a common prefix count as a single return
-- when calculating the number of returns.
listObjectVersionsResponse_commonPrefixes :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe [CommonPrefix])
listObjectVersionsResponse_commonPrefixes :: Lens' ListObjectVersionsResponse (Maybe [CommonPrefix])
listObjectVersionsResponse_commonPrefixes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe [CommonPrefix]
commonPrefixes :: Maybe [CommonPrefix]
$sel:commonPrefixes:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe [CommonPrefix]
commonPrefixes} -> Maybe [CommonPrefix]
commonPrefixes) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe [CommonPrefix]
a -> ListObjectVersionsResponse
s {$sel:commonPrefixes:ListObjectVersionsResponse' :: Maybe [CommonPrefix]
commonPrefixes = Maybe [CommonPrefix]
a} :: ListObjectVersionsResponse) 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

-- | Container for an object that is a delete marker.
listObjectVersionsResponse_deleteMarkers :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe [DeleteMarkerEntry])
listObjectVersionsResponse_deleteMarkers :: Lens' ListObjectVersionsResponse (Maybe [DeleteMarkerEntry])
listObjectVersionsResponse_deleteMarkers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe [DeleteMarkerEntry]
deleteMarkers :: Maybe [DeleteMarkerEntry]
$sel:deleteMarkers:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe [DeleteMarkerEntry]
deleteMarkers} -> Maybe [DeleteMarkerEntry]
deleteMarkers) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe [DeleteMarkerEntry]
a -> ListObjectVersionsResponse
s {$sel:deleteMarkers:ListObjectVersionsResponse' :: Maybe [DeleteMarkerEntry]
deleteMarkers = Maybe [DeleteMarkerEntry]
a} :: ListObjectVersionsResponse) 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 delimiter grouping the included keys. A delimiter is a character
-- that you specify to group keys. All keys that contain the same string
-- between the prefix and the first occurrence of the delimiter are grouped
-- under a single result element in @CommonPrefixes@. These groups are
-- counted as one result against the max-keys limitation. These keys are
-- not returned elsewhere in the response.
listObjectVersionsResponse_delimiter :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe Delimiter)
listObjectVersionsResponse_delimiter :: Lens' ListObjectVersionsResponse (Maybe Delimiter)
listObjectVersionsResponse_delimiter = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe Delimiter
delimiter :: Maybe Delimiter
$sel:delimiter:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Delimiter
delimiter} -> Maybe Delimiter
delimiter) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe Delimiter
a -> ListObjectVersionsResponse
s {$sel:delimiter:ListObjectVersionsResponse' :: Maybe Delimiter
delimiter = Maybe Delimiter
a} :: ListObjectVersionsResponse)

-- | Encoding type used by Amazon S3 to encode object key names in the XML
-- response.
--
-- If you specify encoding-type request parameter, Amazon S3 includes this
-- element in the response, and returns encoded key name values in the
-- following response elements:
--
-- @KeyMarker, NextKeyMarker, Prefix, Key@, and @Delimiter@.
listObjectVersionsResponse_encodingType :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe EncodingType)
listObjectVersionsResponse_encodingType :: Lens' ListObjectVersionsResponse (Maybe EncodingType)
listObjectVersionsResponse_encodingType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe EncodingType
encodingType :: Maybe EncodingType
$sel:encodingType:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe EncodingType
encodingType} -> Maybe EncodingType
encodingType) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe EncodingType
a -> ListObjectVersionsResponse
s {$sel:encodingType:ListObjectVersionsResponse' :: Maybe EncodingType
encodingType = Maybe EncodingType
a} :: ListObjectVersionsResponse)

-- | A flag that indicates whether Amazon S3 returned all of the results that
-- satisfied the search criteria. If your results were truncated, you can
-- make a follow-up paginated request using the NextKeyMarker and
-- NextVersionIdMarker response parameters as a starting place in another
-- request to return the rest of the results.
listObjectVersionsResponse_isTruncated :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe Prelude.Bool)
listObjectVersionsResponse_isTruncated :: Lens' ListObjectVersionsResponse (Maybe Bool)
listObjectVersionsResponse_isTruncated = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe Bool
isTruncated :: Maybe Bool
$sel:isTruncated:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Bool
isTruncated} -> Maybe Bool
isTruncated) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe Bool
a -> ListObjectVersionsResponse
s {$sel:isTruncated:ListObjectVersionsResponse' :: Maybe Bool
isTruncated = Maybe Bool
a} :: ListObjectVersionsResponse)

-- | Marks the last key returned in a truncated response.
listObjectVersionsResponse_keyMarker :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe Prelude.Text)
listObjectVersionsResponse_keyMarker :: Lens' ListObjectVersionsResponse (Maybe Text)
listObjectVersionsResponse_keyMarker = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe Text
keyMarker :: Maybe Text
$sel:keyMarker:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
keyMarker} -> Maybe Text
keyMarker) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe Text
a -> ListObjectVersionsResponse
s {$sel:keyMarker:ListObjectVersionsResponse' :: Maybe Text
keyMarker = Maybe Text
a} :: ListObjectVersionsResponse)

-- | Specifies the maximum number of objects to return.
listObjectVersionsResponse_maxKeys :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe Prelude.Int)
listObjectVersionsResponse_maxKeys :: Lens' ListObjectVersionsResponse (Maybe Int)
listObjectVersionsResponse_maxKeys = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe Int
maxKeys :: Maybe Int
$sel:maxKeys:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Int
maxKeys} -> Maybe Int
maxKeys) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe Int
a -> ListObjectVersionsResponse
s {$sel:maxKeys:ListObjectVersionsResponse' :: Maybe Int
maxKeys = Maybe Int
a} :: ListObjectVersionsResponse)

-- | The bucket name.
listObjectVersionsResponse_name :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe BucketName)
listObjectVersionsResponse_name :: Lens' ListObjectVersionsResponse (Maybe BucketName)
listObjectVersionsResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe BucketName
name :: Maybe BucketName
$sel:name:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe BucketName
name} -> Maybe BucketName
name) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe BucketName
a -> ListObjectVersionsResponse
s {$sel:name:ListObjectVersionsResponse' :: Maybe BucketName
name = Maybe BucketName
a} :: ListObjectVersionsResponse)

-- | When the number of responses exceeds the value of @MaxKeys@,
-- @NextKeyMarker@ specifies the first key not returned that satisfies the
-- search criteria. Use this value for the key-marker request parameter in
-- a subsequent request.
listObjectVersionsResponse_nextKeyMarker :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe Prelude.Text)
listObjectVersionsResponse_nextKeyMarker :: Lens' ListObjectVersionsResponse (Maybe Text)
listObjectVersionsResponse_nextKeyMarker = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe Text
nextKeyMarker :: Maybe Text
$sel:nextKeyMarker:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
nextKeyMarker} -> Maybe Text
nextKeyMarker) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe Text
a -> ListObjectVersionsResponse
s {$sel:nextKeyMarker:ListObjectVersionsResponse' :: Maybe Text
nextKeyMarker = Maybe Text
a} :: ListObjectVersionsResponse)

-- | When the number of responses exceeds the value of @MaxKeys@,
-- @NextVersionIdMarker@ specifies the first object version not returned
-- that satisfies the search criteria. Use this value for the
-- version-id-marker request parameter in a subsequent request.
listObjectVersionsResponse_nextVersionIdMarker :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe Prelude.Text)
listObjectVersionsResponse_nextVersionIdMarker :: Lens' ListObjectVersionsResponse (Maybe Text)
listObjectVersionsResponse_nextVersionIdMarker = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe Text
nextVersionIdMarker :: Maybe Text
$sel:nextVersionIdMarker:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
nextVersionIdMarker} -> Maybe Text
nextVersionIdMarker) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe Text
a -> ListObjectVersionsResponse
s {$sel:nextVersionIdMarker:ListObjectVersionsResponse' :: Maybe Text
nextVersionIdMarker = Maybe Text
a} :: ListObjectVersionsResponse)

-- | Selects objects that start with the value supplied by this parameter.
listObjectVersionsResponse_prefix :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe Prelude.Text)
listObjectVersionsResponse_prefix :: Lens' ListObjectVersionsResponse (Maybe Text)
listObjectVersionsResponse_prefix = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe Text
prefix :: Maybe Text
$sel:prefix:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
prefix} -> Maybe Text
prefix) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe Text
a -> ListObjectVersionsResponse
s {$sel:prefix:ListObjectVersionsResponse' :: Maybe Text
prefix = Maybe Text
a} :: ListObjectVersionsResponse)

-- | Marks the last version of the key returned in a truncated response.
listObjectVersionsResponse_versionIdMarker :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe Prelude.Text)
listObjectVersionsResponse_versionIdMarker :: Lens' ListObjectVersionsResponse (Maybe Text)
listObjectVersionsResponse_versionIdMarker = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe Text
versionIdMarker :: Maybe Text
$sel:versionIdMarker:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
versionIdMarker} -> Maybe Text
versionIdMarker) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe Text
a -> ListObjectVersionsResponse
s {$sel:versionIdMarker:ListObjectVersionsResponse' :: Maybe Text
versionIdMarker = Maybe Text
a} :: ListObjectVersionsResponse)

-- | Container for version information.
listObjectVersionsResponse_versions :: Lens.Lens' ListObjectVersionsResponse (Prelude.Maybe [ObjectVersion])
listObjectVersionsResponse_versions :: Lens' ListObjectVersionsResponse (Maybe [ObjectVersion])
listObjectVersionsResponse_versions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Maybe [ObjectVersion]
versions :: Maybe [ObjectVersion]
$sel:versions:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe [ObjectVersion]
versions} -> Maybe [ObjectVersion]
versions) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Maybe [ObjectVersion]
a -> ListObjectVersionsResponse
s {$sel:versions:ListObjectVersionsResponse' :: Maybe [ObjectVersion]
versions = Maybe [ObjectVersion]
a} :: ListObjectVersionsResponse) 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.
listObjectVersionsResponse_httpStatus :: Lens.Lens' ListObjectVersionsResponse Prelude.Int
listObjectVersionsResponse_httpStatus :: Lens' ListObjectVersionsResponse Int
listObjectVersionsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectVersionsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListObjectVersionsResponse
s@ListObjectVersionsResponse' {} Int
a -> ListObjectVersionsResponse
s {$sel:httpStatus:ListObjectVersionsResponse' :: Int
httpStatus = Int
a} :: ListObjectVersionsResponse)

instance Prelude.NFData ListObjectVersionsResponse where
  rnf :: ListObjectVersionsResponse -> ()
rnf ListObjectVersionsResponse' {Int
Maybe Bool
Maybe Delimiter
Maybe Int
Maybe [CommonPrefix]
Maybe [ObjectVersion]
Maybe [DeleteMarkerEntry]
Maybe Text
Maybe BucketName
Maybe EncodingType
httpStatus :: Int
versions :: Maybe [ObjectVersion]
versionIdMarker :: Maybe Text
prefix :: Maybe Text
nextVersionIdMarker :: Maybe Text
nextKeyMarker :: Maybe Text
name :: Maybe BucketName
maxKeys :: Maybe Int
keyMarker :: Maybe Text
isTruncated :: Maybe Bool
encodingType :: Maybe EncodingType
delimiter :: Maybe Delimiter
deleteMarkers :: Maybe [DeleteMarkerEntry]
commonPrefixes :: Maybe [CommonPrefix]
$sel:httpStatus:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Int
$sel:versions:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe [ObjectVersion]
$sel:versionIdMarker:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
$sel:prefix:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
$sel:nextVersionIdMarker:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
$sel:nextKeyMarker:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
$sel:name:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe BucketName
$sel:maxKeys:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Int
$sel:keyMarker:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Text
$sel:isTruncated:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Bool
$sel:encodingType:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe EncodingType
$sel:delimiter:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe Delimiter
$sel:deleteMarkers:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe [DeleteMarkerEntry]
$sel:commonPrefixes:ListObjectVersionsResponse' :: ListObjectVersionsResponse -> Maybe [CommonPrefix]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [CommonPrefix]
commonPrefixes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [DeleteMarkerEntry]
deleteMarkers
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Delimiter
delimiter
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EncodingType
encodingType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
isTruncated
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
keyMarker
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
maxKeys
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe BucketName
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextKeyMarker
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextVersionIdMarker
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
prefix
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
versionIdMarker
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ObjectVersion]
versions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus