{-# 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.DynamoDB.BatchGetItem
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- The @BatchGetItem@ operation returns the attributes of one or more items
-- from one or more tables. You identify requested items by primary key.
--
-- A single operation can retrieve up to 16 MB of data, which can contain
-- as many as 100 items. @BatchGetItem@ returns a partial result if the
-- response size limit is exceeded, the table\'s provisioned throughput is
-- exceeded, or an internal processing failure occurs. If a partial result
-- is returned, the operation returns a value for @UnprocessedKeys@. You
-- can use this value to retry the operation starting with the next item to
-- get.
--
-- If you request more than 100 items, @BatchGetItem@ returns a
-- @ValidationException@ with the message \"Too many items requested for
-- the BatchGetItem call.\"
--
-- For example, if you ask to retrieve 100 items, but each individual item
-- is 300 KB in size, the system returns 52 items (so as not to exceed the
-- 16 MB limit). It also returns an appropriate @UnprocessedKeys@ value so
-- you can get the next page of results. If desired, your application can
-- include its own logic to assemble the pages of results into one dataset.
--
-- If /none/ of the items can be processed due to insufficient provisioned
-- throughput on all of the tables in the request, then @BatchGetItem@
-- returns a @ProvisionedThroughputExceededException@. If /at least one/ of
-- the items is successfully processed, then @BatchGetItem@ completes
-- successfully, while returning the keys of the unread items in
-- @UnprocessedKeys@.
--
-- If DynamoDB returns any unprocessed items, you should retry the batch
-- operation on those items. However, /we strongly recommend that you use
-- an exponential backoff algorithm/. If you retry the batch operation
-- immediately, the underlying read or write requests can still fail due to
-- throttling on the individual tables. If you delay the batch operation
-- using exponential backoff, the individual requests in the batch are much
-- more likely to succeed.
--
-- For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations Batch Operations and Error Handling>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- By default, @BatchGetItem@ performs eventually consistent reads on every
-- table in the request. If you want strongly consistent reads instead, you
-- can set @ConsistentRead@ to @true@ for any or all tables.
--
-- In order to minimize response latency, @BatchGetItem@ retrieves items in
-- parallel.
--
-- When designing your application, keep in mind that DynamoDB does not
-- return items in any particular order. To help parse the response by
-- item, include the primary key values for the items in your request in
-- the @ProjectionExpression@ parameter.
--
-- If a requested item does not exist, it is not returned in the result.
-- Requests for nonexistent items consume the minimum read capacity units
-- according to the type of read. For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#CapacityUnitCalculations Working with Tables>
-- in the /Amazon DynamoDB Developer Guide/.
module Amazonka.DynamoDB.BatchGetItem
  ( -- * Creating a Request
    BatchGetItem (..),
    newBatchGetItem,

    -- * Request Lenses
    batchGetItem_returnConsumedCapacity,
    batchGetItem_requestItems,

    -- * Destructuring the Response
    BatchGetItemResponse (..),
    newBatchGetItemResponse,

    -- * Response Lenses
    batchGetItemResponse_unprocessedKeys,
    batchGetItemResponse_responses,
    batchGetItemResponse_consumedCapacity,
    batchGetItemResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import Amazonka.DynamoDB.Types
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | Represents the input of a @BatchGetItem@ operation.
--
-- /See:/ 'newBatchGetItem' smart constructor.
data BatchGetItem = BatchGetItem'
  { BatchGetItem -> Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Prelude.Maybe ReturnConsumedCapacity,
    -- | A map of one or more table names and, for each table, a map that
    -- describes one or more items to retrieve from that table. Each table name
    -- can be used only once per @BatchGetItem@ request.
    --
    -- Each element in the map of items to retrieve consists of the following:
    --
    -- -   @ConsistentRead@ - If @true@, a strongly consistent read is used; if
    --     @false@ (the default), an eventually consistent read is used.
    --
    -- -   @ExpressionAttributeNames@ - One or more substitution tokens for
    --     attribute names in the @ProjectionExpression@ parameter. The
    --     following are some use cases for using @ExpressionAttributeNames@:
    --
    --     -   To access an attribute whose name conflicts with a DynamoDB
    --         reserved word.
    --
    --     -   To create a placeholder for repeating occurrences of an
    --         attribute name in an expression.
    --
    --     -   To prevent special characters in an attribute name from being
    --         misinterpreted in an expression.
    --
    --     Use the __#__ character in an expression to dereference an attribute
    --     name. For example, consider the following attribute name:
    --
    --     -   @Percentile@
    --
    --     The name of this attribute conflicts with a reserved word, so it
    --     cannot be used directly in an expression. (For the complete list of
    --     reserved words, see
    --     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html Reserved Words>
    --     in the /Amazon DynamoDB Developer Guide/). To work around this, you
    --     could specify the following for @ExpressionAttributeNames@:
    --
    --     -   @{\"#P\":\"Percentile\"}@
    --
    --     You could then use this substitution in an expression, as in this
    --     example:
    --
    --     -   @#P = :val@
    --
    --     Tokens that begin with the __:__ character are /expression attribute
    --     values/, which are placeholders for the actual value at runtime.
    --
    --     For more information about expression attribute names, see
    --     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Accessing Item Attributes>
    --     in the /Amazon DynamoDB Developer Guide/.
    --
    -- -   @Keys@ - An array of primary key attribute values that define
    --     specific items in the table. For each primary key, you must provide
    --     /all/ of the key attributes. For example, with a simple primary key,
    --     you only need to provide the partition key value. For a composite
    --     key, you must provide /both/ the partition key value and the sort
    --     key value.
    --
    -- -   @ProjectionExpression@ - A string that identifies one or more
    --     attributes to retrieve from the table. These attributes can include
    --     scalars, sets, or elements of a JSON document. The attributes in the
    --     expression must be separated by commas.
    --
    --     If no attribute names are specified, then all attributes are
    --     returned. If any of the requested attributes are not found, they do
    --     not appear in the result.
    --
    --     For more information, see
    --     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Accessing Item Attributes>
    --     in the /Amazon DynamoDB Developer Guide/.
    --
    -- -   @AttributesToGet@ - This is a legacy parameter. Use
    --     @ProjectionExpression@ instead. For more information, see
    --     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html AttributesToGet>
    --     in the /Amazon DynamoDB Developer Guide/.
    BatchGetItem -> HashMap Text KeysAndAttributes
requestItems :: Prelude.HashMap Prelude.Text KeysAndAttributes
  }
  deriving (BatchGetItem -> BatchGetItem -> Bool
(BatchGetItem -> BatchGetItem -> Bool)
-> (BatchGetItem -> BatchGetItem -> Bool) -> Eq BatchGetItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BatchGetItem -> BatchGetItem -> Bool
$c/= :: BatchGetItem -> BatchGetItem -> Bool
== :: BatchGetItem -> BatchGetItem -> Bool
$c== :: BatchGetItem -> BatchGetItem -> Bool
Prelude.Eq, ReadPrec [BatchGetItem]
ReadPrec BatchGetItem
Int -> ReadS BatchGetItem
ReadS [BatchGetItem]
(Int -> ReadS BatchGetItem)
-> ReadS [BatchGetItem]
-> ReadPrec BatchGetItem
-> ReadPrec [BatchGetItem]
-> Read BatchGetItem
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BatchGetItem]
$creadListPrec :: ReadPrec [BatchGetItem]
readPrec :: ReadPrec BatchGetItem
$creadPrec :: ReadPrec BatchGetItem
readList :: ReadS [BatchGetItem]
$creadList :: ReadS [BatchGetItem]
readsPrec :: Int -> ReadS BatchGetItem
$creadsPrec :: Int -> ReadS BatchGetItem
Prelude.Read, Int -> BatchGetItem -> ShowS
[BatchGetItem] -> ShowS
BatchGetItem -> String
(Int -> BatchGetItem -> ShowS)
-> (BatchGetItem -> String)
-> ([BatchGetItem] -> ShowS)
-> Show BatchGetItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BatchGetItem] -> ShowS
$cshowList :: [BatchGetItem] -> ShowS
show :: BatchGetItem -> String
$cshow :: BatchGetItem -> String
showsPrec :: Int -> BatchGetItem -> ShowS
$cshowsPrec :: Int -> BatchGetItem -> ShowS
Prelude.Show, (forall x. BatchGetItem -> Rep BatchGetItem x)
-> (forall x. Rep BatchGetItem x -> BatchGetItem)
-> Generic BatchGetItem
forall x. Rep BatchGetItem x -> BatchGetItem
forall x. BatchGetItem -> Rep BatchGetItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BatchGetItem x -> BatchGetItem
$cfrom :: forall x. BatchGetItem -> Rep BatchGetItem x
Prelude.Generic)

-- |
-- Create a value of 'BatchGetItem' 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:
--
-- 'returnConsumedCapacity', 'batchGetItem_returnConsumedCapacity' - Undocumented member.
--
-- 'requestItems', 'batchGetItem_requestItems' - A map of one or more table names and, for each table, a map that
-- describes one or more items to retrieve from that table. Each table name
-- can be used only once per @BatchGetItem@ request.
--
-- Each element in the map of items to retrieve consists of the following:
--
-- -   @ConsistentRead@ - If @true@, a strongly consistent read is used; if
--     @false@ (the default), an eventually consistent read is used.
--
-- -   @ExpressionAttributeNames@ - One or more substitution tokens for
--     attribute names in the @ProjectionExpression@ parameter. The
--     following are some use cases for using @ExpressionAttributeNames@:
--
--     -   To access an attribute whose name conflicts with a DynamoDB
--         reserved word.
--
--     -   To create a placeholder for repeating occurrences of an
--         attribute name in an expression.
--
--     -   To prevent special characters in an attribute name from being
--         misinterpreted in an expression.
--
--     Use the __#__ character in an expression to dereference an attribute
--     name. For example, consider the following attribute name:
--
--     -   @Percentile@
--
--     The name of this attribute conflicts with a reserved word, so it
--     cannot be used directly in an expression. (For the complete list of
--     reserved words, see
--     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html Reserved Words>
--     in the /Amazon DynamoDB Developer Guide/). To work around this, you
--     could specify the following for @ExpressionAttributeNames@:
--
--     -   @{\"#P\":\"Percentile\"}@
--
--     You could then use this substitution in an expression, as in this
--     example:
--
--     -   @#P = :val@
--
--     Tokens that begin with the __:__ character are /expression attribute
--     values/, which are placeholders for the actual value at runtime.
--
--     For more information about expression attribute names, see
--     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Accessing Item Attributes>
--     in the /Amazon DynamoDB Developer Guide/.
--
-- -   @Keys@ - An array of primary key attribute values that define
--     specific items in the table. For each primary key, you must provide
--     /all/ of the key attributes. For example, with a simple primary key,
--     you only need to provide the partition key value. For a composite
--     key, you must provide /both/ the partition key value and the sort
--     key value.
--
-- -   @ProjectionExpression@ - A string that identifies one or more
--     attributes to retrieve from the table. These attributes can include
--     scalars, sets, or elements of a JSON document. The attributes in the
--     expression must be separated by commas.
--
--     If no attribute names are specified, then all attributes are
--     returned. If any of the requested attributes are not found, they do
--     not appear in the result.
--
--     For more information, see
--     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Accessing Item Attributes>
--     in the /Amazon DynamoDB Developer Guide/.
--
-- -   @AttributesToGet@ - This is a legacy parameter. Use
--     @ProjectionExpression@ instead. For more information, see
--     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html AttributesToGet>
--     in the /Amazon DynamoDB Developer Guide/.
newBatchGetItem ::
  BatchGetItem
newBatchGetItem :: BatchGetItem
newBatchGetItem =
  BatchGetItem' :: Maybe ReturnConsumedCapacity
-> HashMap Text KeysAndAttributes -> BatchGetItem
BatchGetItem'
    { $sel:returnConsumedCapacity:BatchGetItem' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity =
        Maybe ReturnConsumedCapacity
forall a. Maybe a
Prelude.Nothing,
      $sel:requestItems:BatchGetItem' :: HashMap Text KeysAndAttributes
requestItems = HashMap Text KeysAndAttributes
forall a. Monoid a => a
Prelude.mempty
    }

-- | Undocumented member.
batchGetItem_returnConsumedCapacity :: Lens.Lens' BatchGetItem (Prelude.Maybe ReturnConsumedCapacity)
batchGetItem_returnConsumedCapacity :: (Maybe ReturnConsumedCapacity -> f (Maybe ReturnConsumedCapacity))
-> BatchGetItem -> f BatchGetItem
batchGetItem_returnConsumedCapacity = (BatchGetItem -> Maybe ReturnConsumedCapacity)
-> (BatchGetItem -> Maybe ReturnConsumedCapacity -> BatchGetItem)
-> Lens
     BatchGetItem
     BatchGetItem
     (Maybe ReturnConsumedCapacity)
     (Maybe ReturnConsumedCapacity)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchGetItem' {Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
$sel:returnConsumedCapacity:BatchGetItem' :: BatchGetItem -> Maybe ReturnConsumedCapacity
returnConsumedCapacity} -> Maybe ReturnConsumedCapacity
returnConsumedCapacity) (\s :: BatchGetItem
s@BatchGetItem' {} Maybe ReturnConsumedCapacity
a -> BatchGetItem
s {$sel:returnConsumedCapacity:BatchGetItem' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity = Maybe ReturnConsumedCapacity
a} :: BatchGetItem)

-- | A map of one or more table names and, for each table, a map that
-- describes one or more items to retrieve from that table. Each table name
-- can be used only once per @BatchGetItem@ request.
--
-- Each element in the map of items to retrieve consists of the following:
--
-- -   @ConsistentRead@ - If @true@, a strongly consistent read is used; if
--     @false@ (the default), an eventually consistent read is used.
--
-- -   @ExpressionAttributeNames@ - One or more substitution tokens for
--     attribute names in the @ProjectionExpression@ parameter. The
--     following are some use cases for using @ExpressionAttributeNames@:
--
--     -   To access an attribute whose name conflicts with a DynamoDB
--         reserved word.
--
--     -   To create a placeholder for repeating occurrences of an
--         attribute name in an expression.
--
--     -   To prevent special characters in an attribute name from being
--         misinterpreted in an expression.
--
--     Use the __#__ character in an expression to dereference an attribute
--     name. For example, consider the following attribute name:
--
--     -   @Percentile@
--
--     The name of this attribute conflicts with a reserved word, so it
--     cannot be used directly in an expression. (For the complete list of
--     reserved words, see
--     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html Reserved Words>
--     in the /Amazon DynamoDB Developer Guide/). To work around this, you
--     could specify the following for @ExpressionAttributeNames@:
--
--     -   @{\"#P\":\"Percentile\"}@
--
--     You could then use this substitution in an expression, as in this
--     example:
--
--     -   @#P = :val@
--
--     Tokens that begin with the __:__ character are /expression attribute
--     values/, which are placeholders for the actual value at runtime.
--
--     For more information about expression attribute names, see
--     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Accessing Item Attributes>
--     in the /Amazon DynamoDB Developer Guide/.
--
-- -   @Keys@ - An array of primary key attribute values that define
--     specific items in the table. For each primary key, you must provide
--     /all/ of the key attributes. For example, with a simple primary key,
--     you only need to provide the partition key value. For a composite
--     key, you must provide /both/ the partition key value and the sort
--     key value.
--
-- -   @ProjectionExpression@ - A string that identifies one or more
--     attributes to retrieve from the table. These attributes can include
--     scalars, sets, or elements of a JSON document. The attributes in the
--     expression must be separated by commas.
--
--     If no attribute names are specified, then all attributes are
--     returned. If any of the requested attributes are not found, they do
--     not appear in the result.
--
--     For more information, see
--     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Accessing Item Attributes>
--     in the /Amazon DynamoDB Developer Guide/.
--
-- -   @AttributesToGet@ - This is a legacy parameter. Use
--     @ProjectionExpression@ instead. For more information, see
--     <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html AttributesToGet>
--     in the /Amazon DynamoDB Developer Guide/.
batchGetItem_requestItems :: Lens.Lens' BatchGetItem (Prelude.HashMap Prelude.Text KeysAndAttributes)
batchGetItem_requestItems :: (HashMap Text KeysAndAttributes
 -> f (HashMap Text KeysAndAttributes))
-> BatchGetItem -> f BatchGetItem
batchGetItem_requestItems = (BatchGetItem -> HashMap Text KeysAndAttributes)
-> (BatchGetItem -> HashMap Text KeysAndAttributes -> BatchGetItem)
-> Lens
     BatchGetItem
     BatchGetItem
     (HashMap Text KeysAndAttributes)
     (HashMap Text KeysAndAttributes)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchGetItem' {HashMap Text KeysAndAttributes
requestItems :: HashMap Text KeysAndAttributes
$sel:requestItems:BatchGetItem' :: BatchGetItem -> HashMap Text KeysAndAttributes
requestItems} -> HashMap Text KeysAndAttributes
requestItems) (\s :: BatchGetItem
s@BatchGetItem' {} HashMap Text KeysAndAttributes
a -> BatchGetItem
s {$sel:requestItems:BatchGetItem' :: HashMap Text KeysAndAttributes
requestItems = HashMap Text KeysAndAttributes
a} :: BatchGetItem) ((HashMap Text KeysAndAttributes
  -> f (HashMap Text KeysAndAttributes))
 -> BatchGetItem -> f BatchGetItem)
-> ((HashMap Text KeysAndAttributes
     -> f (HashMap Text KeysAndAttributes))
    -> HashMap Text KeysAndAttributes
    -> f (HashMap Text KeysAndAttributes))
-> (HashMap Text KeysAndAttributes
    -> f (HashMap Text KeysAndAttributes))
-> BatchGetItem
-> f BatchGetItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (HashMap Text KeysAndAttributes
 -> f (HashMap Text KeysAndAttributes))
-> HashMap Text KeysAndAttributes
-> f (HashMap Text KeysAndAttributes)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest BatchGetItem where
  type AWSResponse BatchGetItem = BatchGetItemResponse
  request :: BatchGetItem -> Request BatchGetItem
request = Service -> BatchGetItem -> Request BatchGetItem
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy BatchGetItem
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse BatchGetItem)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse BatchGetItem))
-> Logger
-> Service
-> Proxy BatchGetItem
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse BatchGetItem)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe (HashMap Text KeysAndAttributes)
-> Maybe (HashMap Text [HashMap Text AttributeValue])
-> Maybe [ConsumedCapacity]
-> Int
-> BatchGetItemResponse
BatchGetItemResponse'
            (Maybe (HashMap Text KeysAndAttributes)
 -> Maybe (HashMap Text [HashMap Text AttributeValue])
 -> Maybe [ConsumedCapacity]
 -> Int
 -> BatchGetItemResponse)
-> Either String (Maybe (HashMap Text KeysAndAttributes))
-> Either
     String
     (Maybe (HashMap Text [HashMap Text AttributeValue])
      -> Maybe [ConsumedCapacity] -> Int -> BatchGetItemResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x Object
-> Text
-> Either String (Maybe (Maybe (HashMap Text KeysAndAttributes)))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"UnprocessedKeys"
                            Either String (Maybe (Maybe (HashMap Text KeysAndAttributes)))
-> Maybe (HashMap Text KeysAndAttributes)
-> Either String (Maybe (HashMap Text KeysAndAttributes))
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe (HashMap Text KeysAndAttributes)
forall a. Monoid a => a
Prelude.mempty
                        )
            Either
  String
  (Maybe (HashMap Text [HashMap Text AttributeValue])
   -> Maybe [ConsumedCapacity] -> Int -> BatchGetItemResponse)
-> Either
     String (Maybe (HashMap Text [HashMap Text AttributeValue]))
-> Either
     String (Maybe [ConsumedCapacity] -> Int -> BatchGetItemResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object
-> Text
-> Either
     String (Maybe (Maybe (HashMap Text [HashMap Text AttributeValue])))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"Responses" Either
  String (Maybe (Maybe (HashMap Text [HashMap Text AttributeValue])))
-> Maybe (HashMap Text [HashMap Text AttributeValue])
-> Either
     String (Maybe (HashMap Text [HashMap Text AttributeValue]))
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe (HashMap Text [HashMap Text AttributeValue])
forall a. Monoid a => a
Prelude.mempty)
            Either
  String (Maybe [ConsumedCapacity] -> Int -> BatchGetItemResponse)
-> Either String (Maybe [ConsumedCapacity])
-> Either String (Int -> BatchGetItemResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Either String (Maybe (Maybe [ConsumedCapacity]))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"ConsumedCapacity"
                            Either String (Maybe (Maybe [ConsumedCapacity]))
-> Maybe [ConsumedCapacity]
-> Either String (Maybe [ConsumedCapacity])
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe [ConsumedCapacity]
forall a. Monoid a => a
Prelude.mempty
                        )
            Either String (Int -> BatchGetItemResponse)
-> Either String Int -> Either String BatchGetItemResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable BatchGetItem

instance Prelude.NFData BatchGetItem

instance Core.ToHeaders BatchGetItem where
  toHeaders :: BatchGetItem -> ResponseHeaders
toHeaders =
    ResponseHeaders -> BatchGetItem -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"DynamoDB_20120810.BatchGetItem" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON BatchGetItem where
  toJSON :: BatchGetItem -> Value
toJSON BatchGetItem' {Maybe ReturnConsumedCapacity
HashMap Text KeysAndAttributes
requestItems :: HashMap Text KeysAndAttributes
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
$sel:requestItems:BatchGetItem' :: BatchGetItem -> HashMap Text KeysAndAttributes
$sel:returnConsumedCapacity:BatchGetItem' :: BatchGetItem -> Maybe ReturnConsumedCapacity
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"ReturnConsumedCapacity" Text -> ReturnConsumedCapacity -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ReturnConsumedCapacity -> Pair)
-> Maybe ReturnConsumedCapacity -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ReturnConsumedCapacity
returnConsumedCapacity,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"RequestItems" Text -> HashMap Text KeysAndAttributes -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= HashMap Text KeysAndAttributes
requestItems)
          ]
      )

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

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

-- | Represents the output of a @BatchGetItem@ operation.
--
-- /See:/ 'newBatchGetItemResponse' smart constructor.
data BatchGetItemResponse = BatchGetItemResponse'
  { -- | A map of tables and their respective keys that were not processed with
    -- the current response. The @UnprocessedKeys@ value is in the same form as
    -- @RequestItems@, so the value can be provided directly to a subsequent
    -- @BatchGetItem@ operation. For more information, see @RequestItems@ in
    -- the Request Parameters section.
    --
    -- Each element consists of:
    --
    -- -   @Keys@ - An array of primary key attribute values that define
    --     specific items in the table.
    --
    -- -   @ProjectionExpression@ - One or more attributes to be retrieved from
    --     the table or index. By default, all attributes are returned. If a
    --     requested attribute is not found, it does not appear in the result.
    --
    -- -   @ConsistentRead@ - The consistency of a read operation. If set to
    --     @true@, then a strongly consistent read is used; otherwise, an
    --     eventually consistent read is used.
    --
    -- If there are no unprocessed keys remaining, the response contains an
    -- empty @UnprocessedKeys@ map.
    BatchGetItemResponse -> Maybe (HashMap Text KeysAndAttributes)
unprocessedKeys :: Prelude.Maybe (Prelude.HashMap Prelude.Text KeysAndAttributes),
    -- | A map of table name to a list of items. Each object in @Responses@
    -- consists of a table name, along with a map of attribute data consisting
    -- of the data type and attribute value.
    BatchGetItemResponse
-> Maybe (HashMap Text [HashMap Text AttributeValue])
responses :: Prelude.Maybe (Prelude.HashMap Prelude.Text [Prelude.HashMap Prelude.Text AttributeValue]),
    -- | The read capacity units consumed by the entire @BatchGetItem@ operation.
    --
    -- Each element consists of:
    --
    -- -   @TableName@ - The table that consumed the provisioned throughput.
    --
    -- -   @CapacityUnits@ - The total number of capacity units consumed.
    BatchGetItemResponse -> Maybe [ConsumedCapacity]
consumedCapacity :: Prelude.Maybe [ConsumedCapacity],
    -- | The response's http status code.
    BatchGetItemResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (BatchGetItemResponse -> BatchGetItemResponse -> Bool
(BatchGetItemResponse -> BatchGetItemResponse -> Bool)
-> (BatchGetItemResponse -> BatchGetItemResponse -> Bool)
-> Eq BatchGetItemResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BatchGetItemResponse -> BatchGetItemResponse -> Bool
$c/= :: BatchGetItemResponse -> BatchGetItemResponse -> Bool
== :: BatchGetItemResponse -> BatchGetItemResponse -> Bool
$c== :: BatchGetItemResponse -> BatchGetItemResponse -> Bool
Prelude.Eq, ReadPrec [BatchGetItemResponse]
ReadPrec BatchGetItemResponse
Int -> ReadS BatchGetItemResponse
ReadS [BatchGetItemResponse]
(Int -> ReadS BatchGetItemResponse)
-> ReadS [BatchGetItemResponse]
-> ReadPrec BatchGetItemResponse
-> ReadPrec [BatchGetItemResponse]
-> Read BatchGetItemResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BatchGetItemResponse]
$creadListPrec :: ReadPrec [BatchGetItemResponse]
readPrec :: ReadPrec BatchGetItemResponse
$creadPrec :: ReadPrec BatchGetItemResponse
readList :: ReadS [BatchGetItemResponse]
$creadList :: ReadS [BatchGetItemResponse]
readsPrec :: Int -> ReadS BatchGetItemResponse
$creadsPrec :: Int -> ReadS BatchGetItemResponse
Prelude.Read, Int -> BatchGetItemResponse -> ShowS
[BatchGetItemResponse] -> ShowS
BatchGetItemResponse -> String
(Int -> BatchGetItemResponse -> ShowS)
-> (BatchGetItemResponse -> String)
-> ([BatchGetItemResponse] -> ShowS)
-> Show BatchGetItemResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BatchGetItemResponse] -> ShowS
$cshowList :: [BatchGetItemResponse] -> ShowS
show :: BatchGetItemResponse -> String
$cshow :: BatchGetItemResponse -> String
showsPrec :: Int -> BatchGetItemResponse -> ShowS
$cshowsPrec :: Int -> BatchGetItemResponse -> ShowS
Prelude.Show, (forall x. BatchGetItemResponse -> Rep BatchGetItemResponse x)
-> (forall x. Rep BatchGetItemResponse x -> BatchGetItemResponse)
-> Generic BatchGetItemResponse
forall x. Rep BatchGetItemResponse x -> BatchGetItemResponse
forall x. BatchGetItemResponse -> Rep BatchGetItemResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BatchGetItemResponse x -> BatchGetItemResponse
$cfrom :: forall x. BatchGetItemResponse -> Rep BatchGetItemResponse x
Prelude.Generic)

-- |
-- Create a value of 'BatchGetItemResponse' 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:
--
-- 'unprocessedKeys', 'batchGetItemResponse_unprocessedKeys' - A map of tables and their respective keys that were not processed with
-- the current response. The @UnprocessedKeys@ value is in the same form as
-- @RequestItems@, so the value can be provided directly to a subsequent
-- @BatchGetItem@ operation. For more information, see @RequestItems@ in
-- the Request Parameters section.
--
-- Each element consists of:
--
-- -   @Keys@ - An array of primary key attribute values that define
--     specific items in the table.
--
-- -   @ProjectionExpression@ - One or more attributes to be retrieved from
--     the table or index. By default, all attributes are returned. If a
--     requested attribute is not found, it does not appear in the result.
--
-- -   @ConsistentRead@ - The consistency of a read operation. If set to
--     @true@, then a strongly consistent read is used; otherwise, an
--     eventually consistent read is used.
--
-- If there are no unprocessed keys remaining, the response contains an
-- empty @UnprocessedKeys@ map.
--
-- 'responses', 'batchGetItemResponse_responses' - A map of table name to a list of items. Each object in @Responses@
-- consists of a table name, along with a map of attribute data consisting
-- of the data type and attribute value.
--
-- 'consumedCapacity', 'batchGetItemResponse_consumedCapacity' - The read capacity units consumed by the entire @BatchGetItem@ operation.
--
-- Each element consists of:
--
-- -   @TableName@ - The table that consumed the provisioned throughput.
--
-- -   @CapacityUnits@ - The total number of capacity units consumed.
--
-- 'httpStatus', 'batchGetItemResponse_httpStatus' - The response's http status code.
newBatchGetItemResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  BatchGetItemResponse
newBatchGetItemResponse :: Int -> BatchGetItemResponse
newBatchGetItemResponse Int
pHttpStatus_ =
  BatchGetItemResponse' :: Maybe (HashMap Text KeysAndAttributes)
-> Maybe (HashMap Text [HashMap Text AttributeValue])
-> Maybe [ConsumedCapacity]
-> Int
-> BatchGetItemResponse
BatchGetItemResponse'
    { $sel:unprocessedKeys:BatchGetItemResponse' :: Maybe (HashMap Text KeysAndAttributes)
unprocessedKeys =
        Maybe (HashMap Text KeysAndAttributes)
forall a. Maybe a
Prelude.Nothing,
      $sel:responses:BatchGetItemResponse' :: Maybe (HashMap Text [HashMap Text AttributeValue])
responses = Maybe (HashMap Text [HashMap Text AttributeValue])
forall a. Maybe a
Prelude.Nothing,
      $sel:consumedCapacity:BatchGetItemResponse' :: Maybe [ConsumedCapacity]
consumedCapacity = Maybe [ConsumedCapacity]
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:BatchGetItemResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A map of tables and their respective keys that were not processed with
-- the current response. The @UnprocessedKeys@ value is in the same form as
-- @RequestItems@, so the value can be provided directly to a subsequent
-- @BatchGetItem@ operation. For more information, see @RequestItems@ in
-- the Request Parameters section.
--
-- Each element consists of:
--
-- -   @Keys@ - An array of primary key attribute values that define
--     specific items in the table.
--
-- -   @ProjectionExpression@ - One or more attributes to be retrieved from
--     the table or index. By default, all attributes are returned. If a
--     requested attribute is not found, it does not appear in the result.
--
-- -   @ConsistentRead@ - The consistency of a read operation. If set to
--     @true@, then a strongly consistent read is used; otherwise, an
--     eventually consistent read is used.
--
-- If there are no unprocessed keys remaining, the response contains an
-- empty @UnprocessedKeys@ map.
batchGetItemResponse_unprocessedKeys :: Lens.Lens' BatchGetItemResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text KeysAndAttributes))
batchGetItemResponse_unprocessedKeys :: (Maybe (HashMap Text KeysAndAttributes)
 -> f (Maybe (HashMap Text KeysAndAttributes)))
-> BatchGetItemResponse -> f BatchGetItemResponse
batchGetItemResponse_unprocessedKeys = (BatchGetItemResponse -> Maybe (HashMap Text KeysAndAttributes))
-> (BatchGetItemResponse
    -> Maybe (HashMap Text KeysAndAttributes) -> BatchGetItemResponse)
-> Lens
     BatchGetItemResponse
     BatchGetItemResponse
     (Maybe (HashMap Text KeysAndAttributes))
     (Maybe (HashMap Text KeysAndAttributes))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchGetItemResponse' {Maybe (HashMap Text KeysAndAttributes)
unprocessedKeys :: Maybe (HashMap Text KeysAndAttributes)
$sel:unprocessedKeys:BatchGetItemResponse' :: BatchGetItemResponse -> Maybe (HashMap Text KeysAndAttributes)
unprocessedKeys} -> Maybe (HashMap Text KeysAndAttributes)
unprocessedKeys) (\s :: BatchGetItemResponse
s@BatchGetItemResponse' {} Maybe (HashMap Text KeysAndAttributes)
a -> BatchGetItemResponse
s {$sel:unprocessedKeys:BatchGetItemResponse' :: Maybe (HashMap Text KeysAndAttributes)
unprocessedKeys = Maybe (HashMap Text KeysAndAttributes)
a} :: BatchGetItemResponse) ((Maybe (HashMap Text KeysAndAttributes)
  -> f (Maybe (HashMap Text KeysAndAttributes)))
 -> BatchGetItemResponse -> f BatchGetItemResponse)
-> ((Maybe (HashMap Text KeysAndAttributes)
     -> f (Maybe (HashMap Text KeysAndAttributes)))
    -> Maybe (HashMap Text KeysAndAttributes)
    -> f (Maybe (HashMap Text KeysAndAttributes)))
-> (Maybe (HashMap Text KeysAndAttributes)
    -> f (Maybe (HashMap Text KeysAndAttributes)))
-> BatchGetItemResponse
-> f BatchGetItemResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text KeysAndAttributes)
  (HashMap Text KeysAndAttributes)
  (HashMap Text KeysAndAttributes)
  (HashMap Text KeysAndAttributes)
-> Iso
     (Maybe (HashMap Text KeysAndAttributes))
     (Maybe (HashMap Text KeysAndAttributes))
     (Maybe (HashMap Text KeysAndAttributes))
     (Maybe (HashMap Text KeysAndAttributes))
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  (HashMap Text KeysAndAttributes)
  (HashMap Text KeysAndAttributes)
  (HashMap Text KeysAndAttributes)
  (HashMap Text KeysAndAttributes)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A map of table name to a list of items. Each object in @Responses@
-- consists of a table name, along with a map of attribute data consisting
-- of the data type and attribute value.
batchGetItemResponse_responses :: Lens.Lens' BatchGetItemResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text [Prelude.HashMap Prelude.Text AttributeValue]))
batchGetItemResponse_responses :: (Maybe (HashMap Text [HashMap Text AttributeValue])
 -> f (Maybe (HashMap Text [HashMap Text AttributeValue])))
-> BatchGetItemResponse -> f BatchGetItemResponse
batchGetItemResponse_responses = (BatchGetItemResponse
 -> Maybe (HashMap Text [HashMap Text AttributeValue]))
-> (BatchGetItemResponse
    -> Maybe (HashMap Text [HashMap Text AttributeValue])
    -> BatchGetItemResponse)
-> Lens
     BatchGetItemResponse
     BatchGetItemResponse
     (Maybe (HashMap Text [HashMap Text AttributeValue]))
     (Maybe (HashMap Text [HashMap Text AttributeValue]))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchGetItemResponse' {Maybe (HashMap Text [HashMap Text AttributeValue])
responses :: Maybe (HashMap Text [HashMap Text AttributeValue])
$sel:responses:BatchGetItemResponse' :: BatchGetItemResponse
-> Maybe (HashMap Text [HashMap Text AttributeValue])
responses} -> Maybe (HashMap Text [HashMap Text AttributeValue])
responses) (\s :: BatchGetItemResponse
s@BatchGetItemResponse' {} Maybe (HashMap Text [HashMap Text AttributeValue])
a -> BatchGetItemResponse
s {$sel:responses:BatchGetItemResponse' :: Maybe (HashMap Text [HashMap Text AttributeValue])
responses = Maybe (HashMap Text [HashMap Text AttributeValue])
a} :: BatchGetItemResponse) ((Maybe (HashMap Text [HashMap Text AttributeValue])
  -> f (Maybe (HashMap Text [HashMap Text AttributeValue])))
 -> BatchGetItemResponse -> f BatchGetItemResponse)
-> ((Maybe (HashMap Text [HashMap Text AttributeValue])
     -> f (Maybe (HashMap Text [HashMap Text AttributeValue])))
    -> Maybe (HashMap Text [HashMap Text AttributeValue])
    -> f (Maybe (HashMap Text [HashMap Text AttributeValue])))
-> (Maybe (HashMap Text [HashMap Text AttributeValue])
    -> f (Maybe (HashMap Text [HashMap Text AttributeValue])))
-> BatchGetItemResponse
-> f BatchGetItemResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text [HashMap Text AttributeValue])
  (HashMap Text [HashMap Text AttributeValue])
  (HashMap Text [HashMap Text AttributeValue])
  (HashMap Text [HashMap Text AttributeValue])
-> Iso
     (Maybe (HashMap Text [HashMap Text AttributeValue]))
     (Maybe (HashMap Text [HashMap Text AttributeValue]))
     (Maybe (HashMap Text [HashMap Text AttributeValue]))
     (Maybe (HashMap Text [HashMap Text AttributeValue]))
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  (HashMap Text [HashMap Text AttributeValue])
  (HashMap Text [HashMap Text AttributeValue])
  (HashMap Text [HashMap Text AttributeValue])
  (HashMap Text [HashMap Text AttributeValue])
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The read capacity units consumed by the entire @BatchGetItem@ operation.
--
-- Each element consists of:
--
-- -   @TableName@ - The table that consumed the provisioned throughput.
--
-- -   @CapacityUnits@ - The total number of capacity units consumed.
batchGetItemResponse_consumedCapacity :: Lens.Lens' BatchGetItemResponse (Prelude.Maybe [ConsumedCapacity])
batchGetItemResponse_consumedCapacity :: (Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
-> BatchGetItemResponse -> f BatchGetItemResponse
batchGetItemResponse_consumedCapacity = (BatchGetItemResponse -> Maybe [ConsumedCapacity])
-> (BatchGetItemResponse
    -> Maybe [ConsumedCapacity] -> BatchGetItemResponse)
-> Lens
     BatchGetItemResponse
     BatchGetItemResponse
     (Maybe [ConsumedCapacity])
     (Maybe [ConsumedCapacity])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchGetItemResponse' {Maybe [ConsumedCapacity]
consumedCapacity :: Maybe [ConsumedCapacity]
$sel:consumedCapacity:BatchGetItemResponse' :: BatchGetItemResponse -> Maybe [ConsumedCapacity]
consumedCapacity} -> Maybe [ConsumedCapacity]
consumedCapacity) (\s :: BatchGetItemResponse
s@BatchGetItemResponse' {} Maybe [ConsumedCapacity]
a -> BatchGetItemResponse
s {$sel:consumedCapacity:BatchGetItemResponse' :: Maybe [ConsumedCapacity]
consumedCapacity = Maybe [ConsumedCapacity]
a} :: BatchGetItemResponse) ((Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
 -> BatchGetItemResponse -> f BatchGetItemResponse)
-> ((Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
    -> Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
-> (Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
-> BatchGetItemResponse
-> f BatchGetItemResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ConsumedCapacity]
  [ConsumedCapacity]
  [ConsumedCapacity]
  [ConsumedCapacity]
-> Iso
     (Maybe [ConsumedCapacity])
     (Maybe [ConsumedCapacity])
     (Maybe [ConsumedCapacity])
     (Maybe [ConsumedCapacity])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  [ConsumedCapacity]
  [ConsumedCapacity]
  [ConsumedCapacity]
  [ConsumedCapacity]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

instance Prelude.NFData BatchGetItemResponse