{-# 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.MediaLive.BatchDelete
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Starts delete of resources.
module Amazonka.MediaLive.BatchDelete
  ( -- * Creating a Request
    BatchDelete' (..),
    newBatchDelete',

    -- * Request Lenses
    batchDelete'_channelIds,
    batchDelete'_inputIds,
    batchDelete'_inputSecurityGroupIds,
    batchDelete'_multiplexIds,

    -- * Destructuring the Response
    BatchDeleteResponse (..),
    newBatchDeleteResponse,

    -- * Response Lenses
    batchDeleteResponse_failed,
    batchDeleteResponse_successful,
    batchDeleteResponse_httpStatus,
  )
where

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

-- | A request to delete resources
--
-- /See:/ 'newBatchDelete'' smart constructor.
data BatchDelete' = BatchDelete''
  { -- | List of channel IDs
    BatchDelete' -> Maybe [Text]
channelIds :: Prelude.Maybe [Prelude.Text],
    -- | List of input IDs
    BatchDelete' -> Maybe [Text]
inputIds :: Prelude.Maybe [Prelude.Text],
    -- | List of input security group IDs
    BatchDelete' -> Maybe [Text]
inputSecurityGroupIds :: Prelude.Maybe [Prelude.Text],
    -- | List of multiplex IDs
    BatchDelete' -> Maybe [Text]
multiplexIds :: Prelude.Maybe [Prelude.Text]
  }
  deriving (BatchDelete' -> BatchDelete' -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BatchDelete' -> BatchDelete' -> Bool
$c/= :: BatchDelete' -> BatchDelete' -> Bool
== :: BatchDelete' -> BatchDelete' -> Bool
$c== :: BatchDelete' -> BatchDelete' -> Bool
Prelude.Eq, ReadPrec [BatchDelete']
ReadPrec BatchDelete'
Int -> ReadS BatchDelete'
ReadS [BatchDelete']
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BatchDelete']
$creadListPrec :: ReadPrec [BatchDelete']
readPrec :: ReadPrec BatchDelete'
$creadPrec :: ReadPrec BatchDelete'
readList :: ReadS [BatchDelete']
$creadList :: ReadS [BatchDelete']
readsPrec :: Int -> ReadS BatchDelete'
$creadsPrec :: Int -> ReadS BatchDelete'
Prelude.Read, Int -> BatchDelete' -> ShowS
[BatchDelete'] -> ShowS
BatchDelete' -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BatchDelete'] -> ShowS
$cshowList :: [BatchDelete'] -> ShowS
show :: BatchDelete' -> String
$cshow :: BatchDelete' -> String
showsPrec :: Int -> BatchDelete' -> ShowS
$cshowsPrec :: Int -> BatchDelete' -> ShowS
Prelude.Show, forall x. Rep BatchDelete' x -> BatchDelete'
forall x. BatchDelete' -> Rep BatchDelete' x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BatchDelete' x -> BatchDelete'
$cfrom :: forall x. BatchDelete' -> Rep BatchDelete' x
Prelude.Generic)

-- |
-- Create a value of 'BatchDelete'' 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:
--
-- 'channelIds', 'batchDelete'_channelIds' - List of channel IDs
--
-- 'inputIds', 'batchDelete'_inputIds' - List of input IDs
--
-- 'inputSecurityGroupIds', 'batchDelete'_inputSecurityGroupIds' - List of input security group IDs
--
-- 'multiplexIds', 'batchDelete'_multiplexIds' - List of multiplex IDs
newBatchDelete' ::
  BatchDelete'
newBatchDelete' :: BatchDelete'
newBatchDelete' =
  BatchDelete''
    { $sel:channelIds:BatchDelete'' :: Maybe [Text]
channelIds = forall a. Maybe a
Prelude.Nothing,
      $sel:inputIds:BatchDelete'' :: Maybe [Text]
inputIds = forall a. Maybe a
Prelude.Nothing,
      $sel:inputSecurityGroupIds:BatchDelete'' :: Maybe [Text]
inputSecurityGroupIds = forall a. Maybe a
Prelude.Nothing,
      $sel:multiplexIds:BatchDelete'' :: Maybe [Text]
multiplexIds = forall a. Maybe a
Prelude.Nothing
    }

-- | List of channel IDs
batchDelete'_channelIds :: Lens.Lens' BatchDelete' (Prelude.Maybe [Prelude.Text])
batchDelete'_channelIds :: Lens' BatchDelete' (Maybe [Text])
batchDelete'_channelIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchDelete'' {Maybe [Text]
channelIds :: Maybe [Text]
$sel:channelIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
channelIds} -> Maybe [Text]
channelIds) (\s :: BatchDelete'
s@BatchDelete'' {} Maybe [Text]
a -> BatchDelete'
s {$sel:channelIds:BatchDelete'' :: Maybe [Text]
channelIds = Maybe [Text]
a} :: BatchDelete') 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

-- | List of input IDs
batchDelete'_inputIds :: Lens.Lens' BatchDelete' (Prelude.Maybe [Prelude.Text])
batchDelete'_inputIds :: Lens' BatchDelete' (Maybe [Text])
batchDelete'_inputIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchDelete'' {Maybe [Text]
inputIds :: Maybe [Text]
$sel:inputIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
inputIds} -> Maybe [Text]
inputIds) (\s :: BatchDelete'
s@BatchDelete'' {} Maybe [Text]
a -> BatchDelete'
s {$sel:inputIds:BatchDelete'' :: Maybe [Text]
inputIds = Maybe [Text]
a} :: BatchDelete') 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

-- | List of input security group IDs
batchDelete'_inputSecurityGroupIds :: Lens.Lens' BatchDelete' (Prelude.Maybe [Prelude.Text])
batchDelete'_inputSecurityGroupIds :: Lens' BatchDelete' (Maybe [Text])
batchDelete'_inputSecurityGroupIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchDelete'' {Maybe [Text]
inputSecurityGroupIds :: Maybe [Text]
$sel:inputSecurityGroupIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
inputSecurityGroupIds} -> Maybe [Text]
inputSecurityGroupIds) (\s :: BatchDelete'
s@BatchDelete'' {} Maybe [Text]
a -> BatchDelete'
s {$sel:inputSecurityGroupIds:BatchDelete'' :: Maybe [Text]
inputSecurityGroupIds = Maybe [Text]
a} :: BatchDelete') 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

-- | List of multiplex IDs
batchDelete'_multiplexIds :: Lens.Lens' BatchDelete' (Prelude.Maybe [Prelude.Text])
batchDelete'_multiplexIds :: Lens' BatchDelete' (Maybe [Text])
batchDelete'_multiplexIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchDelete'' {Maybe [Text]
multiplexIds :: Maybe [Text]
$sel:multiplexIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
multiplexIds} -> Maybe [Text]
multiplexIds) (\s :: BatchDelete'
s@BatchDelete'' {} Maybe [Text]
a -> BatchDelete'
s {$sel:multiplexIds:BatchDelete'' :: Maybe [Text]
multiplexIds = Maybe [Text]
a} :: BatchDelete') 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

instance Core.AWSRequest BatchDelete' where
  type AWSResponse BatchDelete' = BatchDeleteResponse
  request :: (Service -> Service) -> BatchDelete' -> Request BatchDelete'
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 BatchDelete'
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse BatchDelete')))
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 [BatchFailedResultModel]
-> Maybe [BatchSuccessfulResultModel] -> Int -> BatchDeleteResponse
BatchDeleteResponse'
            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
"failed" 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
"successful" 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 BatchDelete' where
  hashWithSalt :: Int -> BatchDelete' -> Int
hashWithSalt Int
_salt BatchDelete'' {Maybe [Text]
multiplexIds :: Maybe [Text]
inputSecurityGroupIds :: Maybe [Text]
inputIds :: Maybe [Text]
channelIds :: Maybe [Text]
$sel:multiplexIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
$sel:inputSecurityGroupIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
$sel:inputIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
$sel:channelIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
channelIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
inputIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
inputSecurityGroupIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
multiplexIds

instance Prelude.NFData BatchDelete' where
  rnf :: BatchDelete' -> ()
rnf BatchDelete'' {Maybe [Text]
multiplexIds :: Maybe [Text]
inputSecurityGroupIds :: Maybe [Text]
inputIds :: Maybe [Text]
channelIds :: Maybe [Text]
$sel:multiplexIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
$sel:inputSecurityGroupIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
$sel:inputIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
$sel:channelIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
channelIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
inputIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
inputSecurityGroupIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
multiplexIds

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

instance Data.ToJSON BatchDelete' where
  toJSON :: BatchDelete' -> Value
toJSON BatchDelete'' {Maybe [Text]
multiplexIds :: Maybe [Text]
inputSecurityGroupIds :: Maybe [Text]
inputIds :: Maybe [Text]
channelIds :: Maybe [Text]
$sel:multiplexIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
$sel:inputSecurityGroupIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
$sel:inputIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
$sel:channelIds:BatchDelete'' :: BatchDelete' -> Maybe [Text]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"channelIds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
channelIds,
            (Key
"inputIds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
inputIds,
            (Key
"inputSecurityGroupIds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
inputSecurityGroupIds,
            (Key
"multiplexIds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
multiplexIds
          ]
      )

instance Data.ToPath BatchDelete' where
  toPath :: BatchDelete' -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/prod/batch/delete"

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

-- | Placeholder documentation for BatchDeleteResponse
--
-- /See:/ 'newBatchDeleteResponse' smart constructor.
data BatchDeleteResponse = BatchDeleteResponse'
  { -- | List of failed operations
    BatchDeleteResponse -> Maybe [BatchFailedResultModel]
failed :: Prelude.Maybe [BatchFailedResultModel],
    -- | List of successful operations
    BatchDeleteResponse -> Maybe [BatchSuccessfulResultModel]
successful :: Prelude.Maybe [BatchSuccessfulResultModel],
    -- | The response's http status code.
    BatchDeleteResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (BatchDeleteResponse -> BatchDeleteResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BatchDeleteResponse -> BatchDeleteResponse -> Bool
$c/= :: BatchDeleteResponse -> BatchDeleteResponse -> Bool
== :: BatchDeleteResponse -> BatchDeleteResponse -> Bool
$c== :: BatchDeleteResponse -> BatchDeleteResponse -> Bool
Prelude.Eq, ReadPrec [BatchDeleteResponse]
ReadPrec BatchDeleteResponse
Int -> ReadS BatchDeleteResponse
ReadS [BatchDeleteResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BatchDeleteResponse]
$creadListPrec :: ReadPrec [BatchDeleteResponse]
readPrec :: ReadPrec BatchDeleteResponse
$creadPrec :: ReadPrec BatchDeleteResponse
readList :: ReadS [BatchDeleteResponse]
$creadList :: ReadS [BatchDeleteResponse]
readsPrec :: Int -> ReadS BatchDeleteResponse
$creadsPrec :: Int -> ReadS BatchDeleteResponse
Prelude.Read, Int -> BatchDeleteResponse -> ShowS
[BatchDeleteResponse] -> ShowS
BatchDeleteResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BatchDeleteResponse] -> ShowS
$cshowList :: [BatchDeleteResponse] -> ShowS
show :: BatchDeleteResponse -> String
$cshow :: BatchDeleteResponse -> String
showsPrec :: Int -> BatchDeleteResponse -> ShowS
$cshowsPrec :: Int -> BatchDeleteResponse -> ShowS
Prelude.Show, forall x. Rep BatchDeleteResponse x -> BatchDeleteResponse
forall x. BatchDeleteResponse -> Rep BatchDeleteResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BatchDeleteResponse x -> BatchDeleteResponse
$cfrom :: forall x. BatchDeleteResponse -> Rep BatchDeleteResponse x
Prelude.Generic)

-- |
-- Create a value of 'BatchDeleteResponse' 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:
--
-- 'failed', 'batchDeleteResponse_failed' - List of failed operations
--
-- 'successful', 'batchDeleteResponse_successful' - List of successful operations
--
-- 'httpStatus', 'batchDeleteResponse_httpStatus' - The response's http status code.
newBatchDeleteResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  BatchDeleteResponse
newBatchDeleteResponse :: Int -> BatchDeleteResponse
newBatchDeleteResponse Int
pHttpStatus_ =
  BatchDeleteResponse'
    { $sel:failed:BatchDeleteResponse' :: Maybe [BatchFailedResultModel]
failed = forall a. Maybe a
Prelude.Nothing,
      $sel:successful:BatchDeleteResponse' :: Maybe [BatchSuccessfulResultModel]
successful = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:BatchDeleteResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | List of failed operations
batchDeleteResponse_failed :: Lens.Lens' BatchDeleteResponse (Prelude.Maybe [BatchFailedResultModel])
batchDeleteResponse_failed :: Lens' BatchDeleteResponse (Maybe [BatchFailedResultModel])
batchDeleteResponse_failed = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchDeleteResponse' {Maybe [BatchFailedResultModel]
failed :: Maybe [BatchFailedResultModel]
$sel:failed:BatchDeleteResponse' :: BatchDeleteResponse -> Maybe [BatchFailedResultModel]
failed} -> Maybe [BatchFailedResultModel]
failed) (\s :: BatchDeleteResponse
s@BatchDeleteResponse' {} Maybe [BatchFailedResultModel]
a -> BatchDeleteResponse
s {$sel:failed:BatchDeleteResponse' :: Maybe [BatchFailedResultModel]
failed = Maybe [BatchFailedResultModel]
a} :: BatchDeleteResponse) 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

-- | List of successful operations
batchDeleteResponse_successful :: Lens.Lens' BatchDeleteResponse (Prelude.Maybe [BatchSuccessfulResultModel])
batchDeleteResponse_successful :: Lens' BatchDeleteResponse (Maybe [BatchSuccessfulResultModel])
batchDeleteResponse_successful = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchDeleteResponse' {Maybe [BatchSuccessfulResultModel]
successful :: Maybe [BatchSuccessfulResultModel]
$sel:successful:BatchDeleteResponse' :: BatchDeleteResponse -> Maybe [BatchSuccessfulResultModel]
successful} -> Maybe [BatchSuccessfulResultModel]
successful) (\s :: BatchDeleteResponse
s@BatchDeleteResponse' {} Maybe [BatchSuccessfulResultModel]
a -> BatchDeleteResponse
s {$sel:successful:BatchDeleteResponse' :: Maybe [BatchSuccessfulResultModel]
successful = Maybe [BatchSuccessfulResultModel]
a} :: BatchDeleteResponse) 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.
batchDeleteResponse_httpStatus :: Lens.Lens' BatchDeleteResponse Prelude.Int
batchDeleteResponse_httpStatus :: Lens' BatchDeleteResponse Int
batchDeleteResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchDeleteResponse' {Int
httpStatus :: Int
$sel:httpStatus:BatchDeleteResponse' :: BatchDeleteResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: BatchDeleteResponse
s@BatchDeleteResponse' {} Int
a -> BatchDeleteResponse
s {$sel:httpStatus:BatchDeleteResponse' :: Int
httpStatus = Int
a} :: BatchDeleteResponse)

instance Prelude.NFData BatchDeleteResponse where
  rnf :: BatchDeleteResponse -> ()
rnf BatchDeleteResponse' {Int
Maybe [BatchFailedResultModel]
Maybe [BatchSuccessfulResultModel]
httpStatus :: Int
successful :: Maybe [BatchSuccessfulResultModel]
failed :: Maybe [BatchFailedResultModel]
$sel:httpStatus:BatchDeleteResponse' :: BatchDeleteResponse -> Int
$sel:successful:BatchDeleteResponse' :: BatchDeleteResponse -> Maybe [BatchSuccessfulResultModel]
$sel:failed:BatchDeleteResponse' :: BatchDeleteResponse -> Maybe [BatchFailedResultModel]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [BatchFailedResultModel]
failed
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [BatchSuccessfulResultModel]
successful
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus