{-# 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.CloudWatchEvents.RemoveTargets
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Removes the specified targets from the specified rule. When the rule is
-- triggered, those targets are no longer be invoked.
--
-- A successful execution of @RemoveTargets@ doesn\'t guarantee all targets
-- are removed from the rule, it means that the target(s) listed in the
-- request are removed.
--
-- When you remove a target, when the associated rule triggers, removed
-- targets might continue to be invoked. Allow a short period of time for
-- changes to take effect.
--
-- This action can partially fail if too many requests are made at the same
-- time. If that happens, @FailedEntryCount@ is non-zero in the response
-- and each entry in @FailedEntries@ provides the ID of the failed target
-- and the error code.
module Amazonka.CloudWatchEvents.RemoveTargets
  ( -- * Creating a Request
    RemoveTargets (..),
    newRemoveTargets,

    -- * Request Lenses
    removeTargets_eventBusName,
    removeTargets_force,
    removeTargets_rule,
    removeTargets_ids,

    -- * Destructuring the Response
    RemoveTargetsResponse (..),
    newRemoveTargetsResponse,

    -- * Response Lenses
    removeTargetsResponse_failedEntries,
    removeTargetsResponse_failedEntryCount,
    removeTargetsResponse_httpStatus,
  )
where

import Amazonka.CloudWatchEvents.Types
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

-- | /See:/ 'newRemoveTargets' smart constructor.
data RemoveTargets = RemoveTargets'
  { -- | The name or ARN of the event bus associated with the rule. If you omit
    -- this, the default event bus is used.
    RemoveTargets -> Maybe Text
eventBusName :: Prelude.Maybe Prelude.Text,
    -- | If this is a managed rule, created by an Amazon Web Services service on
    -- your behalf, you must specify @Force@ as @True@ to remove targets. This
    -- parameter is ignored for rules that are not managed rules. You can check
    -- whether a rule is a managed rule by using @DescribeRule@ or @ListRules@
    -- and checking the @ManagedBy@ field of the response.
    RemoveTargets -> Maybe Bool
force :: Prelude.Maybe Prelude.Bool,
    -- | The name of the rule.
    RemoveTargets -> Text
rule :: Prelude.Text,
    -- | The IDs of the targets to remove from the rule.
    RemoveTargets -> NonEmpty Text
ids :: Prelude.NonEmpty Prelude.Text
  }
  deriving (RemoveTargets -> RemoveTargets -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoveTargets -> RemoveTargets -> Bool
$c/= :: RemoveTargets -> RemoveTargets -> Bool
== :: RemoveTargets -> RemoveTargets -> Bool
$c== :: RemoveTargets -> RemoveTargets -> Bool
Prelude.Eq, ReadPrec [RemoveTargets]
ReadPrec RemoveTargets
Int -> ReadS RemoveTargets
ReadS [RemoveTargets]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RemoveTargets]
$creadListPrec :: ReadPrec [RemoveTargets]
readPrec :: ReadPrec RemoveTargets
$creadPrec :: ReadPrec RemoveTargets
readList :: ReadS [RemoveTargets]
$creadList :: ReadS [RemoveTargets]
readsPrec :: Int -> ReadS RemoveTargets
$creadsPrec :: Int -> ReadS RemoveTargets
Prelude.Read, Int -> RemoveTargets -> ShowS
[RemoveTargets] -> ShowS
RemoveTargets -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RemoveTargets] -> ShowS
$cshowList :: [RemoveTargets] -> ShowS
show :: RemoveTargets -> String
$cshow :: RemoveTargets -> String
showsPrec :: Int -> RemoveTargets -> ShowS
$cshowsPrec :: Int -> RemoveTargets -> ShowS
Prelude.Show, forall x. Rep RemoveTargets x -> RemoveTargets
forall x. RemoveTargets -> Rep RemoveTargets x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RemoveTargets x -> RemoveTargets
$cfrom :: forall x. RemoveTargets -> Rep RemoveTargets x
Prelude.Generic)

-- |
-- Create a value of 'RemoveTargets' 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:
--
-- 'eventBusName', 'removeTargets_eventBusName' - The name or ARN of the event bus associated with the rule. If you omit
-- this, the default event bus is used.
--
-- 'force', 'removeTargets_force' - If this is a managed rule, created by an Amazon Web Services service on
-- your behalf, you must specify @Force@ as @True@ to remove targets. This
-- parameter is ignored for rules that are not managed rules. You can check
-- whether a rule is a managed rule by using @DescribeRule@ or @ListRules@
-- and checking the @ManagedBy@ field of the response.
--
-- 'rule', 'removeTargets_rule' - The name of the rule.
--
-- 'ids', 'removeTargets_ids' - The IDs of the targets to remove from the rule.
newRemoveTargets ::
  -- | 'rule'
  Prelude.Text ->
  -- | 'ids'
  Prelude.NonEmpty Prelude.Text ->
  RemoveTargets
newRemoveTargets :: Text -> NonEmpty Text -> RemoveTargets
newRemoveTargets Text
pRule_ NonEmpty Text
pIds_ =
  RemoveTargets'
    { $sel:eventBusName:RemoveTargets' :: Maybe Text
eventBusName = forall a. Maybe a
Prelude.Nothing,
      $sel:force:RemoveTargets' :: Maybe Bool
force = forall a. Maybe a
Prelude.Nothing,
      $sel:rule:RemoveTargets' :: Text
rule = Text
pRule_,
      $sel:ids:RemoveTargets' :: NonEmpty Text
ids = forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty Text
pIds_
    }

-- | The name or ARN of the event bus associated with the rule. If you omit
-- this, the default event bus is used.
removeTargets_eventBusName :: Lens.Lens' RemoveTargets (Prelude.Maybe Prelude.Text)
removeTargets_eventBusName :: Lens' RemoveTargets (Maybe Text)
removeTargets_eventBusName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RemoveTargets' {Maybe Text
eventBusName :: Maybe Text
$sel:eventBusName:RemoveTargets' :: RemoveTargets -> Maybe Text
eventBusName} -> Maybe Text
eventBusName) (\s :: RemoveTargets
s@RemoveTargets' {} Maybe Text
a -> RemoveTargets
s {$sel:eventBusName:RemoveTargets' :: Maybe Text
eventBusName = Maybe Text
a} :: RemoveTargets)

-- | If this is a managed rule, created by an Amazon Web Services service on
-- your behalf, you must specify @Force@ as @True@ to remove targets. This
-- parameter is ignored for rules that are not managed rules. You can check
-- whether a rule is a managed rule by using @DescribeRule@ or @ListRules@
-- and checking the @ManagedBy@ field of the response.
removeTargets_force :: Lens.Lens' RemoveTargets (Prelude.Maybe Prelude.Bool)
removeTargets_force :: Lens' RemoveTargets (Maybe Bool)
removeTargets_force = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RemoveTargets' {Maybe Bool
force :: Maybe Bool
$sel:force:RemoveTargets' :: RemoveTargets -> Maybe Bool
force} -> Maybe Bool
force) (\s :: RemoveTargets
s@RemoveTargets' {} Maybe Bool
a -> RemoveTargets
s {$sel:force:RemoveTargets' :: Maybe Bool
force = Maybe Bool
a} :: RemoveTargets)

-- | The name of the rule.
removeTargets_rule :: Lens.Lens' RemoveTargets Prelude.Text
removeTargets_rule :: Lens' RemoveTargets Text
removeTargets_rule = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RemoveTargets' {Text
rule :: Text
$sel:rule:RemoveTargets' :: RemoveTargets -> Text
rule} -> Text
rule) (\s :: RemoveTargets
s@RemoveTargets' {} Text
a -> RemoveTargets
s {$sel:rule:RemoveTargets' :: Text
rule = Text
a} :: RemoveTargets)

-- | The IDs of the targets to remove from the rule.
removeTargets_ids :: Lens.Lens' RemoveTargets (Prelude.NonEmpty Prelude.Text)
removeTargets_ids :: Lens' RemoveTargets (NonEmpty Text)
removeTargets_ids = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RemoveTargets' {NonEmpty Text
ids :: NonEmpty Text
$sel:ids:RemoveTargets' :: RemoveTargets -> NonEmpty Text
ids} -> NonEmpty Text
ids) (\s :: RemoveTargets
s@RemoveTargets' {} NonEmpty Text
a -> RemoveTargets
s {$sel:ids:RemoveTargets' :: NonEmpty Text
ids = NonEmpty Text
a} :: RemoveTargets) 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

instance Core.AWSRequest RemoveTargets where
  type
    AWSResponse RemoveTargets =
      RemoveTargetsResponse
  request :: (Service -> Service) -> RemoveTargets -> Request RemoveTargets
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 RemoveTargets
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse RemoveTargets)))
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 [RemoveTargetsResultEntry]
-> Maybe Int -> Int -> RemoveTargetsResponse
RemoveTargetsResponse'
            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
"FailedEntries" 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
"FailedEntryCount")
            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 RemoveTargets where
  hashWithSalt :: Int -> RemoveTargets -> Int
hashWithSalt Int
_salt RemoveTargets' {Maybe Bool
Maybe Text
NonEmpty Text
Text
ids :: NonEmpty Text
rule :: Text
force :: Maybe Bool
eventBusName :: Maybe Text
$sel:ids:RemoveTargets' :: RemoveTargets -> NonEmpty Text
$sel:rule:RemoveTargets' :: RemoveTargets -> Text
$sel:force:RemoveTargets' :: RemoveTargets -> Maybe Bool
$sel:eventBusName:RemoveTargets' :: RemoveTargets -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
eventBusName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
force
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
rule
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Text
ids

instance Prelude.NFData RemoveTargets where
  rnf :: RemoveTargets -> ()
rnf RemoveTargets' {Maybe Bool
Maybe Text
NonEmpty Text
Text
ids :: NonEmpty Text
rule :: Text
force :: Maybe Bool
eventBusName :: Maybe Text
$sel:ids:RemoveTargets' :: RemoveTargets -> NonEmpty Text
$sel:rule:RemoveTargets' :: RemoveTargets -> Text
$sel:force:RemoveTargets' :: RemoveTargets -> Maybe Bool
$sel:eventBusName:RemoveTargets' :: RemoveTargets -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eventBusName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
force
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
rule
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Text
ids

instance Data.ToHeaders RemoveTargets where
  toHeaders :: RemoveTargets -> 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
"AWSEvents.RemoveTargets" :: 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 RemoveTargets where
  toJSON :: RemoveTargets -> Value
toJSON RemoveTargets' {Maybe Bool
Maybe Text
NonEmpty Text
Text
ids :: NonEmpty Text
rule :: Text
force :: Maybe Bool
eventBusName :: Maybe Text
$sel:ids:RemoveTargets' :: RemoveTargets -> NonEmpty Text
$sel:rule:RemoveTargets' :: RemoveTargets -> Text
$sel:force:RemoveTargets' :: RemoveTargets -> Maybe Bool
$sel:eventBusName:RemoveTargets' :: RemoveTargets -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"EventBusName" 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
eventBusName,
            (Key
"Force" 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 Bool
force,
            forall a. a -> Maybe a
Prelude.Just (Key
"Rule" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
rule),
            forall a. a -> Maybe a
Prelude.Just (Key
"Ids" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Text
ids)
          ]
      )

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

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

-- | /See:/ 'newRemoveTargetsResponse' smart constructor.
data RemoveTargetsResponse = RemoveTargetsResponse'
  { -- | The failed target entries.
    RemoveTargetsResponse -> Maybe [RemoveTargetsResultEntry]
failedEntries :: Prelude.Maybe [RemoveTargetsResultEntry],
    -- | The number of failed entries.
    RemoveTargetsResponse -> Maybe Int
failedEntryCount :: Prelude.Maybe Prelude.Int,
    -- | The response's http status code.
    RemoveTargetsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (RemoveTargetsResponse -> RemoveTargetsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoveTargetsResponse -> RemoveTargetsResponse -> Bool
$c/= :: RemoveTargetsResponse -> RemoveTargetsResponse -> Bool
== :: RemoveTargetsResponse -> RemoveTargetsResponse -> Bool
$c== :: RemoveTargetsResponse -> RemoveTargetsResponse -> Bool
Prelude.Eq, ReadPrec [RemoveTargetsResponse]
ReadPrec RemoveTargetsResponse
Int -> ReadS RemoveTargetsResponse
ReadS [RemoveTargetsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RemoveTargetsResponse]
$creadListPrec :: ReadPrec [RemoveTargetsResponse]
readPrec :: ReadPrec RemoveTargetsResponse
$creadPrec :: ReadPrec RemoveTargetsResponse
readList :: ReadS [RemoveTargetsResponse]
$creadList :: ReadS [RemoveTargetsResponse]
readsPrec :: Int -> ReadS RemoveTargetsResponse
$creadsPrec :: Int -> ReadS RemoveTargetsResponse
Prelude.Read, Int -> RemoveTargetsResponse -> ShowS
[RemoveTargetsResponse] -> ShowS
RemoveTargetsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RemoveTargetsResponse] -> ShowS
$cshowList :: [RemoveTargetsResponse] -> ShowS
show :: RemoveTargetsResponse -> String
$cshow :: RemoveTargetsResponse -> String
showsPrec :: Int -> RemoveTargetsResponse -> ShowS
$cshowsPrec :: Int -> RemoveTargetsResponse -> ShowS
Prelude.Show, forall x. Rep RemoveTargetsResponse x -> RemoveTargetsResponse
forall x. RemoveTargetsResponse -> Rep RemoveTargetsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RemoveTargetsResponse x -> RemoveTargetsResponse
$cfrom :: forall x. RemoveTargetsResponse -> Rep RemoveTargetsResponse x
Prelude.Generic)

-- |
-- Create a value of 'RemoveTargetsResponse' 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:
--
-- 'failedEntries', 'removeTargetsResponse_failedEntries' - The failed target entries.
--
-- 'failedEntryCount', 'removeTargetsResponse_failedEntryCount' - The number of failed entries.
--
-- 'httpStatus', 'removeTargetsResponse_httpStatus' - The response's http status code.
newRemoveTargetsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RemoveTargetsResponse
newRemoveTargetsResponse :: Int -> RemoveTargetsResponse
newRemoveTargetsResponse Int
pHttpStatus_ =
  RemoveTargetsResponse'
    { $sel:failedEntries:RemoveTargetsResponse' :: Maybe [RemoveTargetsResultEntry]
failedEntries =
        forall a. Maybe a
Prelude.Nothing,
      $sel:failedEntryCount:RemoveTargetsResponse' :: Maybe Int
failedEntryCount = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RemoveTargetsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The failed target entries.
removeTargetsResponse_failedEntries :: Lens.Lens' RemoveTargetsResponse (Prelude.Maybe [RemoveTargetsResultEntry])
removeTargetsResponse_failedEntries :: Lens' RemoveTargetsResponse (Maybe [RemoveTargetsResultEntry])
removeTargetsResponse_failedEntries = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RemoveTargetsResponse' {Maybe [RemoveTargetsResultEntry]
failedEntries :: Maybe [RemoveTargetsResultEntry]
$sel:failedEntries:RemoveTargetsResponse' :: RemoveTargetsResponse -> Maybe [RemoveTargetsResultEntry]
failedEntries} -> Maybe [RemoveTargetsResultEntry]
failedEntries) (\s :: RemoveTargetsResponse
s@RemoveTargetsResponse' {} Maybe [RemoveTargetsResultEntry]
a -> RemoveTargetsResponse
s {$sel:failedEntries:RemoveTargetsResponse' :: Maybe [RemoveTargetsResultEntry]
failedEntries = Maybe [RemoveTargetsResultEntry]
a} :: RemoveTargetsResponse) 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 number of failed entries.
removeTargetsResponse_failedEntryCount :: Lens.Lens' RemoveTargetsResponse (Prelude.Maybe Prelude.Int)
removeTargetsResponse_failedEntryCount :: Lens' RemoveTargetsResponse (Maybe Int)
removeTargetsResponse_failedEntryCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RemoveTargetsResponse' {Maybe Int
failedEntryCount :: Maybe Int
$sel:failedEntryCount:RemoveTargetsResponse' :: RemoveTargetsResponse -> Maybe Int
failedEntryCount} -> Maybe Int
failedEntryCount) (\s :: RemoveTargetsResponse
s@RemoveTargetsResponse' {} Maybe Int
a -> RemoveTargetsResponse
s {$sel:failedEntryCount:RemoveTargetsResponse' :: Maybe Int
failedEntryCount = Maybe Int
a} :: RemoveTargetsResponse)

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

instance Prelude.NFData RemoveTargetsResponse where
  rnf :: RemoveTargetsResponse -> ()
rnf RemoveTargetsResponse' {Int
Maybe Int
Maybe [RemoveTargetsResultEntry]
httpStatus :: Int
failedEntryCount :: Maybe Int
failedEntries :: Maybe [RemoveTargetsResultEntry]
$sel:httpStatus:RemoveTargetsResponse' :: RemoveTargetsResponse -> Int
$sel:failedEntryCount:RemoveTargetsResponse' :: RemoveTargetsResponse -> Maybe Int
$sel:failedEntries:RemoveTargetsResponse' :: RemoveTargetsResponse -> Maybe [RemoveTargetsResultEntry]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [RemoveTargetsResultEntry]
failedEntries
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
failedEntryCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus