{-# 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.MarketplaceMetering.BatchMeterUsage
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- @BatchMeterUsage@ is called from a SaaS application listed on AWS
-- Marketplace to post metering records for a set of customers.
--
-- For identical requests, the API is idempotent; requests can be retried
-- with the same records or a subset of the input records.
--
-- Every request to @BatchMeterUsage@ is for one product. If you need to
-- meter usage for multiple products, you must make multiple calls to
-- @BatchMeterUsage@.
--
-- Usage records are expected to be submitted as quickly as possible after
-- the event that is being recorded, and are not accepted more than 6 hours
-- after the event.
--
-- @BatchMeterUsage@ can process up to 25 @UsageRecords@ at a time.
--
-- A @UsageRecord@ can optionally include multiple usage allocations, to
-- provide customers with usage data split into buckets by tags that you
-- define (or allow the customer to define).
--
-- @BatchMeterUsage@ returns a list of @UsageRecordResult@ objects, showing
-- the result for each @UsageRecord@, as well as a list of
-- @UnprocessedRecords@, indicating errors in the service side that you
-- should retry.
--
-- @BatchMeterUsage@ requests must be less than 1MB in size.
--
-- For an example of using @BatchMeterUsage@, see
-- <https://docs.aws.amazon.com/marketplace/latest/userguide/saas-code-examples.html#saas-batchmeterusage-example BatchMeterUsage code example>
-- in the /AWS Marketplace Seller Guide/.
module Amazonka.MarketplaceMetering.BatchMeterUsage
  ( -- * Creating a Request
    BatchMeterUsage (..),
    newBatchMeterUsage,

    -- * Request Lenses
    batchMeterUsage_usageRecords,
    batchMeterUsage_productCode,

    -- * Destructuring the Response
    BatchMeterUsageResponse (..),
    newBatchMeterUsageResponse,

    -- * Response Lenses
    batchMeterUsageResponse_results,
    batchMeterUsageResponse_unprocessedRecords,
    batchMeterUsageResponse_httpStatus,
  )
where

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

-- | A @BatchMeterUsageRequest@ contains @UsageRecords@, which indicate
-- quantities of usage within your application.
--
-- /See:/ 'newBatchMeterUsage' smart constructor.
data BatchMeterUsage = BatchMeterUsage'
  { -- | The set of @UsageRecords@ to submit. @BatchMeterUsage@ accepts up to 25
    -- @UsageRecords@ at a time.
    BatchMeterUsage -> [UsageRecord]
usageRecords :: [UsageRecord],
    -- | Product code is used to uniquely identify a product in AWS Marketplace.
    -- The product code should be the same as the one used during the
    -- publishing of a new product.
    BatchMeterUsage -> Text
productCode :: Prelude.Text
  }
  deriving (BatchMeterUsage -> BatchMeterUsage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BatchMeterUsage -> BatchMeterUsage -> Bool
$c/= :: BatchMeterUsage -> BatchMeterUsage -> Bool
== :: BatchMeterUsage -> BatchMeterUsage -> Bool
$c== :: BatchMeterUsage -> BatchMeterUsage -> Bool
Prelude.Eq, ReadPrec [BatchMeterUsage]
ReadPrec BatchMeterUsage
Int -> ReadS BatchMeterUsage
ReadS [BatchMeterUsage]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BatchMeterUsage]
$creadListPrec :: ReadPrec [BatchMeterUsage]
readPrec :: ReadPrec BatchMeterUsage
$creadPrec :: ReadPrec BatchMeterUsage
readList :: ReadS [BatchMeterUsage]
$creadList :: ReadS [BatchMeterUsage]
readsPrec :: Int -> ReadS BatchMeterUsage
$creadsPrec :: Int -> ReadS BatchMeterUsage
Prelude.Read, Int -> BatchMeterUsage -> ShowS
[BatchMeterUsage] -> ShowS
BatchMeterUsage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BatchMeterUsage] -> ShowS
$cshowList :: [BatchMeterUsage] -> ShowS
show :: BatchMeterUsage -> String
$cshow :: BatchMeterUsage -> String
showsPrec :: Int -> BatchMeterUsage -> ShowS
$cshowsPrec :: Int -> BatchMeterUsage -> ShowS
Prelude.Show, forall x. Rep BatchMeterUsage x -> BatchMeterUsage
forall x. BatchMeterUsage -> Rep BatchMeterUsage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BatchMeterUsage x -> BatchMeterUsage
$cfrom :: forall x. BatchMeterUsage -> Rep BatchMeterUsage x
Prelude.Generic)

-- |
-- Create a value of 'BatchMeterUsage' 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:
--
-- 'usageRecords', 'batchMeterUsage_usageRecords' - The set of @UsageRecords@ to submit. @BatchMeterUsage@ accepts up to 25
-- @UsageRecords@ at a time.
--
-- 'productCode', 'batchMeterUsage_productCode' - Product code is used to uniquely identify a product in AWS Marketplace.
-- The product code should be the same as the one used during the
-- publishing of a new product.
newBatchMeterUsage ::
  -- | 'productCode'
  Prelude.Text ->
  BatchMeterUsage
newBatchMeterUsage :: Text -> BatchMeterUsage
newBatchMeterUsage Text
pProductCode_ =
  BatchMeterUsage'
    { $sel:usageRecords:BatchMeterUsage' :: [UsageRecord]
usageRecords = forall a. Monoid a => a
Prelude.mempty,
      $sel:productCode:BatchMeterUsage' :: Text
productCode = Text
pProductCode_
    }

-- | The set of @UsageRecords@ to submit. @BatchMeterUsage@ accepts up to 25
-- @UsageRecords@ at a time.
batchMeterUsage_usageRecords :: Lens.Lens' BatchMeterUsage [UsageRecord]
batchMeterUsage_usageRecords :: Lens' BatchMeterUsage [UsageRecord]
batchMeterUsage_usageRecords = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchMeterUsage' {[UsageRecord]
usageRecords :: [UsageRecord]
$sel:usageRecords:BatchMeterUsage' :: BatchMeterUsage -> [UsageRecord]
usageRecords} -> [UsageRecord]
usageRecords) (\s :: BatchMeterUsage
s@BatchMeterUsage' {} [UsageRecord]
a -> BatchMeterUsage
s {$sel:usageRecords:BatchMeterUsage' :: [UsageRecord]
usageRecords = [UsageRecord]
a} :: BatchMeterUsage) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Product code is used to uniquely identify a product in AWS Marketplace.
-- The product code should be the same as the one used during the
-- publishing of a new product.
batchMeterUsage_productCode :: Lens.Lens' BatchMeterUsage Prelude.Text
batchMeterUsage_productCode :: Lens' BatchMeterUsage Text
batchMeterUsage_productCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchMeterUsage' {Text
productCode :: Text
$sel:productCode:BatchMeterUsage' :: BatchMeterUsage -> Text
productCode} -> Text
productCode) (\s :: BatchMeterUsage
s@BatchMeterUsage' {} Text
a -> BatchMeterUsage
s {$sel:productCode:BatchMeterUsage' :: Text
productCode = Text
a} :: BatchMeterUsage)

instance Core.AWSRequest BatchMeterUsage where
  type
    AWSResponse BatchMeterUsage =
      BatchMeterUsageResponse
  request :: (Service -> Service) -> BatchMeterUsage -> Request BatchMeterUsage
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy BatchMeterUsage
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse BatchMeterUsage)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe [UsageRecordResult]
-> Maybe [UsageRecord] -> Int -> BatchMeterUsageResponse
BatchMeterUsageResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Results" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"UnprocessedRecords"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable BatchMeterUsage where
  hashWithSalt :: Int -> BatchMeterUsage -> Int
hashWithSalt Int
_salt BatchMeterUsage' {[UsageRecord]
Text
productCode :: Text
usageRecords :: [UsageRecord]
$sel:productCode:BatchMeterUsage' :: BatchMeterUsage -> Text
$sel:usageRecords:BatchMeterUsage' :: BatchMeterUsage -> [UsageRecord]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [UsageRecord]
usageRecords
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
productCode

instance Prelude.NFData BatchMeterUsage where
  rnf :: BatchMeterUsage -> ()
rnf BatchMeterUsage' {[UsageRecord]
Text
productCode :: Text
usageRecords :: [UsageRecord]
$sel:productCode:BatchMeterUsage' :: BatchMeterUsage -> Text
$sel:usageRecords:BatchMeterUsage' :: BatchMeterUsage -> [UsageRecord]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf [UsageRecord]
usageRecords
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
productCode

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

instance Data.ToJSON BatchMeterUsage where
  toJSON :: BatchMeterUsage -> Value
toJSON BatchMeterUsage' {[UsageRecord]
Text
productCode :: Text
usageRecords :: [UsageRecord]
$sel:productCode:BatchMeterUsage' :: BatchMeterUsage -> Text
$sel:usageRecords:BatchMeterUsage' :: BatchMeterUsage -> [UsageRecord]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"UsageRecords" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [UsageRecord]
usageRecords),
            forall a. a -> Maybe a
Prelude.Just (Key
"ProductCode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
productCode)
          ]
      )

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

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

-- | Contains the @UsageRecords@ processed by @BatchMeterUsage@ and any
-- records that have failed due to transient error.
--
-- /See:/ 'newBatchMeterUsageResponse' smart constructor.
data BatchMeterUsageResponse = BatchMeterUsageResponse'
  { -- | Contains all @UsageRecords@ processed by @BatchMeterUsage@. These
    -- records were either honored by AWS Marketplace Metering Service or were
    -- invalid. Invalid records should be fixed before being resubmitted.
    BatchMeterUsageResponse -> Maybe [UsageRecordResult]
results :: Prelude.Maybe [UsageRecordResult],
    -- | Contains all @UsageRecords@ that were not processed by
    -- @BatchMeterUsage@. This is a list of @UsageRecords@. You can retry the
    -- failed request by making another @BatchMeterUsage@ call with this list
    -- as input in the @BatchMeterUsageRequest@.
    BatchMeterUsageResponse -> Maybe [UsageRecord]
unprocessedRecords :: Prelude.Maybe [UsageRecord],
    -- | The response's http status code.
    BatchMeterUsageResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (BatchMeterUsageResponse -> BatchMeterUsageResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BatchMeterUsageResponse -> BatchMeterUsageResponse -> Bool
$c/= :: BatchMeterUsageResponse -> BatchMeterUsageResponse -> Bool
== :: BatchMeterUsageResponse -> BatchMeterUsageResponse -> Bool
$c== :: BatchMeterUsageResponse -> BatchMeterUsageResponse -> Bool
Prelude.Eq, ReadPrec [BatchMeterUsageResponse]
ReadPrec BatchMeterUsageResponse
Int -> ReadS BatchMeterUsageResponse
ReadS [BatchMeterUsageResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BatchMeterUsageResponse]
$creadListPrec :: ReadPrec [BatchMeterUsageResponse]
readPrec :: ReadPrec BatchMeterUsageResponse
$creadPrec :: ReadPrec BatchMeterUsageResponse
readList :: ReadS [BatchMeterUsageResponse]
$creadList :: ReadS [BatchMeterUsageResponse]
readsPrec :: Int -> ReadS BatchMeterUsageResponse
$creadsPrec :: Int -> ReadS BatchMeterUsageResponse
Prelude.Read, Int -> BatchMeterUsageResponse -> ShowS
[BatchMeterUsageResponse] -> ShowS
BatchMeterUsageResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BatchMeterUsageResponse] -> ShowS
$cshowList :: [BatchMeterUsageResponse] -> ShowS
show :: BatchMeterUsageResponse -> String
$cshow :: BatchMeterUsageResponse -> String
showsPrec :: Int -> BatchMeterUsageResponse -> ShowS
$cshowsPrec :: Int -> BatchMeterUsageResponse -> ShowS
Prelude.Show, forall x. Rep BatchMeterUsageResponse x -> BatchMeterUsageResponse
forall x. BatchMeterUsageResponse -> Rep BatchMeterUsageResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BatchMeterUsageResponse x -> BatchMeterUsageResponse
$cfrom :: forall x. BatchMeterUsageResponse -> Rep BatchMeterUsageResponse x
Prelude.Generic)

-- |
-- Create a value of 'BatchMeterUsageResponse' 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:
--
-- 'results', 'batchMeterUsageResponse_results' - Contains all @UsageRecords@ processed by @BatchMeterUsage@. These
-- records were either honored by AWS Marketplace Metering Service or were
-- invalid. Invalid records should be fixed before being resubmitted.
--
-- 'unprocessedRecords', 'batchMeterUsageResponse_unprocessedRecords' - Contains all @UsageRecords@ that were not processed by
-- @BatchMeterUsage@. This is a list of @UsageRecords@. You can retry the
-- failed request by making another @BatchMeterUsage@ call with this list
-- as input in the @BatchMeterUsageRequest@.
--
-- 'httpStatus', 'batchMeterUsageResponse_httpStatus' - The response's http status code.
newBatchMeterUsageResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  BatchMeterUsageResponse
newBatchMeterUsageResponse :: Int -> BatchMeterUsageResponse
newBatchMeterUsageResponse Int
pHttpStatus_ =
  BatchMeterUsageResponse'
    { $sel:results:BatchMeterUsageResponse' :: Maybe [UsageRecordResult]
results = forall a. Maybe a
Prelude.Nothing,
      $sel:unprocessedRecords:BatchMeterUsageResponse' :: Maybe [UsageRecord]
unprocessedRecords = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:BatchMeterUsageResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Contains all @UsageRecords@ processed by @BatchMeterUsage@. These
-- records were either honored by AWS Marketplace Metering Service or were
-- invalid. Invalid records should be fixed before being resubmitted.
batchMeterUsageResponse_results :: Lens.Lens' BatchMeterUsageResponse (Prelude.Maybe [UsageRecordResult])
batchMeterUsageResponse_results :: Lens' BatchMeterUsageResponse (Maybe [UsageRecordResult])
batchMeterUsageResponse_results = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchMeterUsageResponse' {Maybe [UsageRecordResult]
results :: Maybe [UsageRecordResult]
$sel:results:BatchMeterUsageResponse' :: BatchMeterUsageResponse -> Maybe [UsageRecordResult]
results} -> Maybe [UsageRecordResult]
results) (\s :: BatchMeterUsageResponse
s@BatchMeterUsageResponse' {} Maybe [UsageRecordResult]
a -> BatchMeterUsageResponse
s {$sel:results:BatchMeterUsageResponse' :: Maybe [UsageRecordResult]
results = Maybe [UsageRecordResult]
a} :: BatchMeterUsageResponse) 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

-- | Contains all @UsageRecords@ that were not processed by
-- @BatchMeterUsage@. This is a list of @UsageRecords@. You can retry the
-- failed request by making another @BatchMeterUsage@ call with this list
-- as input in the @BatchMeterUsageRequest@.
batchMeterUsageResponse_unprocessedRecords :: Lens.Lens' BatchMeterUsageResponse (Prelude.Maybe [UsageRecord])
batchMeterUsageResponse_unprocessedRecords :: Lens' BatchMeterUsageResponse (Maybe [UsageRecord])
batchMeterUsageResponse_unprocessedRecords = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchMeterUsageResponse' {Maybe [UsageRecord]
unprocessedRecords :: Maybe [UsageRecord]
$sel:unprocessedRecords:BatchMeterUsageResponse' :: BatchMeterUsageResponse -> Maybe [UsageRecord]
unprocessedRecords} -> Maybe [UsageRecord]
unprocessedRecords) (\s :: BatchMeterUsageResponse
s@BatchMeterUsageResponse' {} Maybe [UsageRecord]
a -> BatchMeterUsageResponse
s {$sel:unprocessedRecords:BatchMeterUsageResponse' :: Maybe [UsageRecord]
unprocessedRecords = Maybe [UsageRecord]
a} :: BatchMeterUsageResponse) 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.
batchMeterUsageResponse_httpStatus :: Lens.Lens' BatchMeterUsageResponse Prelude.Int
batchMeterUsageResponse_httpStatus :: Lens' BatchMeterUsageResponse Int
batchMeterUsageResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchMeterUsageResponse' {Int
httpStatus :: Int
$sel:httpStatus:BatchMeterUsageResponse' :: BatchMeterUsageResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: BatchMeterUsageResponse
s@BatchMeterUsageResponse' {} Int
a -> BatchMeterUsageResponse
s {$sel:httpStatus:BatchMeterUsageResponse' :: Int
httpStatus = Int
a} :: BatchMeterUsageResponse)

instance Prelude.NFData BatchMeterUsageResponse where
  rnf :: BatchMeterUsageResponse -> ()
rnf BatchMeterUsageResponse' {Int
Maybe [UsageRecord]
Maybe [UsageRecordResult]
httpStatus :: Int
unprocessedRecords :: Maybe [UsageRecord]
results :: Maybe [UsageRecordResult]
$sel:httpStatus:BatchMeterUsageResponse' :: BatchMeterUsageResponse -> Int
$sel:unprocessedRecords:BatchMeterUsageResponse' :: BatchMeterUsageResponse -> Maybe [UsageRecord]
$sel:results:BatchMeterUsageResponse' :: BatchMeterUsageResponse -> Maybe [UsageRecordResult]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [UsageRecordResult]
results
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [UsageRecord]
unprocessedRecords
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus