{-# 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.MediaConnect.RevokeFlowEntitlement
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Revokes an entitlement from a flow. Once an entitlement is revoked, the
-- content becomes unavailable to the subscriber and the associated output
-- is removed.
module Amazonka.MediaConnect.RevokeFlowEntitlement
  ( -- * Creating a Request
    RevokeFlowEntitlement (..),
    newRevokeFlowEntitlement,

    -- * Request Lenses
    revokeFlowEntitlement_flowArn,
    revokeFlowEntitlement_entitlementArn,

    -- * Destructuring the Response
    RevokeFlowEntitlementResponse (..),
    newRevokeFlowEntitlementResponse,

    -- * Response Lenses
    revokeFlowEntitlementResponse_entitlementArn,
    revokeFlowEntitlementResponse_flowArn,
    revokeFlowEntitlementResponse_httpStatus,
  )
where

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

-- | /See:/ 'newRevokeFlowEntitlement' smart constructor.
data RevokeFlowEntitlement = RevokeFlowEntitlement'
  { -- | The flow that you want to revoke an entitlement from.
    RevokeFlowEntitlement -> Text
flowArn :: Prelude.Text,
    -- | The ARN of the entitlement that you want to revoke.
    RevokeFlowEntitlement -> Text
entitlementArn :: Prelude.Text
  }
  deriving (RevokeFlowEntitlement -> RevokeFlowEntitlement -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RevokeFlowEntitlement -> RevokeFlowEntitlement -> Bool
$c/= :: RevokeFlowEntitlement -> RevokeFlowEntitlement -> Bool
== :: RevokeFlowEntitlement -> RevokeFlowEntitlement -> Bool
$c== :: RevokeFlowEntitlement -> RevokeFlowEntitlement -> Bool
Prelude.Eq, ReadPrec [RevokeFlowEntitlement]
ReadPrec RevokeFlowEntitlement
Int -> ReadS RevokeFlowEntitlement
ReadS [RevokeFlowEntitlement]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RevokeFlowEntitlement]
$creadListPrec :: ReadPrec [RevokeFlowEntitlement]
readPrec :: ReadPrec RevokeFlowEntitlement
$creadPrec :: ReadPrec RevokeFlowEntitlement
readList :: ReadS [RevokeFlowEntitlement]
$creadList :: ReadS [RevokeFlowEntitlement]
readsPrec :: Int -> ReadS RevokeFlowEntitlement
$creadsPrec :: Int -> ReadS RevokeFlowEntitlement
Prelude.Read, Int -> RevokeFlowEntitlement -> ShowS
[RevokeFlowEntitlement] -> ShowS
RevokeFlowEntitlement -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RevokeFlowEntitlement] -> ShowS
$cshowList :: [RevokeFlowEntitlement] -> ShowS
show :: RevokeFlowEntitlement -> String
$cshow :: RevokeFlowEntitlement -> String
showsPrec :: Int -> RevokeFlowEntitlement -> ShowS
$cshowsPrec :: Int -> RevokeFlowEntitlement -> ShowS
Prelude.Show, forall x. Rep RevokeFlowEntitlement x -> RevokeFlowEntitlement
forall x. RevokeFlowEntitlement -> Rep RevokeFlowEntitlement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RevokeFlowEntitlement x -> RevokeFlowEntitlement
$cfrom :: forall x. RevokeFlowEntitlement -> Rep RevokeFlowEntitlement x
Prelude.Generic)

-- |
-- Create a value of 'RevokeFlowEntitlement' 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:
--
-- 'flowArn', 'revokeFlowEntitlement_flowArn' - The flow that you want to revoke an entitlement from.
--
-- 'entitlementArn', 'revokeFlowEntitlement_entitlementArn' - The ARN of the entitlement that you want to revoke.
newRevokeFlowEntitlement ::
  -- | 'flowArn'
  Prelude.Text ->
  -- | 'entitlementArn'
  Prelude.Text ->
  RevokeFlowEntitlement
newRevokeFlowEntitlement :: Text -> Text -> RevokeFlowEntitlement
newRevokeFlowEntitlement Text
pFlowArn_ Text
pEntitlementArn_ =
  RevokeFlowEntitlement'
    { $sel:flowArn:RevokeFlowEntitlement' :: Text
flowArn = Text
pFlowArn_,
      $sel:entitlementArn:RevokeFlowEntitlement' :: Text
entitlementArn = Text
pEntitlementArn_
    }

-- | The flow that you want to revoke an entitlement from.
revokeFlowEntitlement_flowArn :: Lens.Lens' RevokeFlowEntitlement Prelude.Text
revokeFlowEntitlement_flowArn :: Lens' RevokeFlowEntitlement Text
revokeFlowEntitlement_flowArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RevokeFlowEntitlement' {Text
flowArn :: Text
$sel:flowArn:RevokeFlowEntitlement' :: RevokeFlowEntitlement -> Text
flowArn} -> Text
flowArn) (\s :: RevokeFlowEntitlement
s@RevokeFlowEntitlement' {} Text
a -> RevokeFlowEntitlement
s {$sel:flowArn:RevokeFlowEntitlement' :: Text
flowArn = Text
a} :: RevokeFlowEntitlement)

-- | The ARN of the entitlement that you want to revoke.
revokeFlowEntitlement_entitlementArn :: Lens.Lens' RevokeFlowEntitlement Prelude.Text
revokeFlowEntitlement_entitlementArn :: Lens' RevokeFlowEntitlement Text
revokeFlowEntitlement_entitlementArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RevokeFlowEntitlement' {Text
entitlementArn :: Text
$sel:entitlementArn:RevokeFlowEntitlement' :: RevokeFlowEntitlement -> Text
entitlementArn} -> Text
entitlementArn) (\s :: RevokeFlowEntitlement
s@RevokeFlowEntitlement' {} Text
a -> RevokeFlowEntitlement
s {$sel:entitlementArn:RevokeFlowEntitlement' :: Text
entitlementArn = Text
a} :: RevokeFlowEntitlement)

instance Core.AWSRequest RevokeFlowEntitlement where
  type
    AWSResponse RevokeFlowEntitlement =
      RevokeFlowEntitlementResponse
  request :: (Service -> Service)
-> RevokeFlowEntitlement -> Request RevokeFlowEntitlement
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.delete (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy RevokeFlowEntitlement
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RevokeFlowEntitlement)))
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 Text -> Maybe Text -> Int -> RevokeFlowEntitlementResponse
RevokeFlowEntitlementResponse'
            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
"entitlementArn")
            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
"flowArn")
            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 RevokeFlowEntitlement where
  hashWithSalt :: Int -> RevokeFlowEntitlement -> Int
hashWithSalt Int
_salt RevokeFlowEntitlement' {Text
entitlementArn :: Text
flowArn :: Text
$sel:entitlementArn:RevokeFlowEntitlement' :: RevokeFlowEntitlement -> Text
$sel:flowArn:RevokeFlowEntitlement' :: RevokeFlowEntitlement -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
flowArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
entitlementArn

instance Prelude.NFData RevokeFlowEntitlement where
  rnf :: RevokeFlowEntitlement -> ()
rnf RevokeFlowEntitlement' {Text
entitlementArn :: Text
flowArn :: Text
$sel:entitlementArn:RevokeFlowEntitlement' :: RevokeFlowEntitlement -> Text
$sel:flowArn:RevokeFlowEntitlement' :: RevokeFlowEntitlement -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
flowArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
entitlementArn

instance Data.ToHeaders RevokeFlowEntitlement where
  toHeaders :: RevokeFlowEntitlement -> 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.ToPath RevokeFlowEntitlement where
  toPath :: RevokeFlowEntitlement -> ByteString
toPath RevokeFlowEntitlement' {Text
entitlementArn :: Text
flowArn :: Text
$sel:entitlementArn:RevokeFlowEntitlement' :: RevokeFlowEntitlement -> Text
$sel:flowArn:RevokeFlowEntitlement' :: RevokeFlowEntitlement -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/v1/flows/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
flowArn,
        ByteString
"/entitlements/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
entitlementArn
      ]

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

-- | /See:/ 'newRevokeFlowEntitlementResponse' smart constructor.
data RevokeFlowEntitlementResponse = RevokeFlowEntitlementResponse'
  { -- | The ARN of the entitlement that was revoked.
    RevokeFlowEntitlementResponse -> Maybe Text
entitlementArn :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the flow that the entitlement was revoked from.
    RevokeFlowEntitlementResponse -> Maybe Text
flowArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    RevokeFlowEntitlementResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (RevokeFlowEntitlementResponse
-> RevokeFlowEntitlementResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RevokeFlowEntitlementResponse
-> RevokeFlowEntitlementResponse -> Bool
$c/= :: RevokeFlowEntitlementResponse
-> RevokeFlowEntitlementResponse -> Bool
== :: RevokeFlowEntitlementResponse
-> RevokeFlowEntitlementResponse -> Bool
$c== :: RevokeFlowEntitlementResponse
-> RevokeFlowEntitlementResponse -> Bool
Prelude.Eq, ReadPrec [RevokeFlowEntitlementResponse]
ReadPrec RevokeFlowEntitlementResponse
Int -> ReadS RevokeFlowEntitlementResponse
ReadS [RevokeFlowEntitlementResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RevokeFlowEntitlementResponse]
$creadListPrec :: ReadPrec [RevokeFlowEntitlementResponse]
readPrec :: ReadPrec RevokeFlowEntitlementResponse
$creadPrec :: ReadPrec RevokeFlowEntitlementResponse
readList :: ReadS [RevokeFlowEntitlementResponse]
$creadList :: ReadS [RevokeFlowEntitlementResponse]
readsPrec :: Int -> ReadS RevokeFlowEntitlementResponse
$creadsPrec :: Int -> ReadS RevokeFlowEntitlementResponse
Prelude.Read, Int -> RevokeFlowEntitlementResponse -> ShowS
[RevokeFlowEntitlementResponse] -> ShowS
RevokeFlowEntitlementResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RevokeFlowEntitlementResponse] -> ShowS
$cshowList :: [RevokeFlowEntitlementResponse] -> ShowS
show :: RevokeFlowEntitlementResponse -> String
$cshow :: RevokeFlowEntitlementResponse -> String
showsPrec :: Int -> RevokeFlowEntitlementResponse -> ShowS
$cshowsPrec :: Int -> RevokeFlowEntitlementResponse -> ShowS
Prelude.Show, forall x.
Rep RevokeFlowEntitlementResponse x
-> RevokeFlowEntitlementResponse
forall x.
RevokeFlowEntitlementResponse
-> Rep RevokeFlowEntitlementResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RevokeFlowEntitlementResponse x
-> RevokeFlowEntitlementResponse
$cfrom :: forall x.
RevokeFlowEntitlementResponse
-> Rep RevokeFlowEntitlementResponse x
Prelude.Generic)

-- |
-- Create a value of 'RevokeFlowEntitlementResponse' 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:
--
-- 'entitlementArn', 'revokeFlowEntitlementResponse_entitlementArn' - The ARN of the entitlement that was revoked.
--
-- 'flowArn', 'revokeFlowEntitlementResponse_flowArn' - The ARN of the flow that the entitlement was revoked from.
--
-- 'httpStatus', 'revokeFlowEntitlementResponse_httpStatus' - The response's http status code.
newRevokeFlowEntitlementResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RevokeFlowEntitlementResponse
newRevokeFlowEntitlementResponse :: Int -> RevokeFlowEntitlementResponse
newRevokeFlowEntitlementResponse Int
pHttpStatus_ =
  RevokeFlowEntitlementResponse'
    { $sel:entitlementArn:RevokeFlowEntitlementResponse' :: Maybe Text
entitlementArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:flowArn:RevokeFlowEntitlementResponse' :: Maybe Text
flowArn = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RevokeFlowEntitlementResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the entitlement that was revoked.
revokeFlowEntitlementResponse_entitlementArn :: Lens.Lens' RevokeFlowEntitlementResponse (Prelude.Maybe Prelude.Text)
revokeFlowEntitlementResponse_entitlementArn :: Lens' RevokeFlowEntitlementResponse (Maybe Text)
revokeFlowEntitlementResponse_entitlementArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RevokeFlowEntitlementResponse' {Maybe Text
entitlementArn :: Maybe Text
$sel:entitlementArn:RevokeFlowEntitlementResponse' :: RevokeFlowEntitlementResponse -> Maybe Text
entitlementArn} -> Maybe Text
entitlementArn) (\s :: RevokeFlowEntitlementResponse
s@RevokeFlowEntitlementResponse' {} Maybe Text
a -> RevokeFlowEntitlementResponse
s {$sel:entitlementArn:RevokeFlowEntitlementResponse' :: Maybe Text
entitlementArn = Maybe Text
a} :: RevokeFlowEntitlementResponse)

-- | The ARN of the flow that the entitlement was revoked from.
revokeFlowEntitlementResponse_flowArn :: Lens.Lens' RevokeFlowEntitlementResponse (Prelude.Maybe Prelude.Text)
revokeFlowEntitlementResponse_flowArn :: Lens' RevokeFlowEntitlementResponse (Maybe Text)
revokeFlowEntitlementResponse_flowArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RevokeFlowEntitlementResponse' {Maybe Text
flowArn :: Maybe Text
$sel:flowArn:RevokeFlowEntitlementResponse' :: RevokeFlowEntitlementResponse -> Maybe Text
flowArn} -> Maybe Text
flowArn) (\s :: RevokeFlowEntitlementResponse
s@RevokeFlowEntitlementResponse' {} Maybe Text
a -> RevokeFlowEntitlementResponse
s {$sel:flowArn:RevokeFlowEntitlementResponse' :: Maybe Text
flowArn = Maybe Text
a} :: RevokeFlowEntitlementResponse)

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

instance Prelude.NFData RevokeFlowEntitlementResponse where
  rnf :: RevokeFlowEntitlementResponse -> ()
rnf RevokeFlowEntitlementResponse' {Int
Maybe Text
httpStatus :: Int
flowArn :: Maybe Text
entitlementArn :: Maybe Text
$sel:httpStatus:RevokeFlowEntitlementResponse' :: RevokeFlowEntitlementResponse -> Int
$sel:flowArn:RevokeFlowEntitlementResponse' :: RevokeFlowEntitlementResponse -> Maybe Text
$sel:entitlementArn:RevokeFlowEntitlementResponse' :: RevokeFlowEntitlementResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
entitlementArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
flowArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus