{-# 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.LexV2Models.CreateResourcePolicyStatement
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Adds a new resource policy statement to a bot or bot alias. If a
-- resource policy exists, the statement is added to the current resource
-- policy. If a policy doesn\'t exist, a new policy is created.
--
-- You can\'t create a resource policy statement that allows cross-account
-- access.
module Amazonka.LexV2Models.CreateResourcePolicyStatement
  ( -- * Creating a Request
    CreateResourcePolicyStatement (..),
    newCreateResourcePolicyStatement,

    -- * Request Lenses
    createResourcePolicyStatement_condition,
    createResourcePolicyStatement_expectedRevisionId,
    createResourcePolicyStatement_resourceArn,
    createResourcePolicyStatement_statementId,
    createResourcePolicyStatement_effect,
    createResourcePolicyStatement_principal,
    createResourcePolicyStatement_action,

    -- * Destructuring the Response
    CreateResourcePolicyStatementResponse (..),
    newCreateResourcePolicyStatementResponse,

    -- * Response Lenses
    createResourcePolicyStatementResponse_resourceArn,
    createResourcePolicyStatementResponse_revisionId,
    createResourcePolicyStatementResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateResourcePolicyStatement' smart constructor.
data CreateResourcePolicyStatement = CreateResourcePolicyStatement'
  { -- | Specifies a condition when the policy is in effect. If the principal of
    -- the policy is a service principal, you must provide two condition
    -- blocks, one with a SourceAccount global condition key and one with a
    -- SourceArn global condition key.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html IAM JSON policy elements: Condition>
    -- .
    CreateResourcePolicyStatement
-> Maybe (HashMap Text (HashMap Text Text))
condition :: Prelude.Maybe (Prelude.HashMap Prelude.Text (Prelude.HashMap Prelude.Text Prelude.Text)),
    -- | The identifier of the revision of the policy to edit. If this revision
    -- ID doesn\'t match the current revision ID, Amazon Lex throws an
    -- exception.
    --
    -- If you don\'t specify a revision, Amazon Lex overwrites the contents of
    -- the policy with the new values.
    CreateResourcePolicyStatement -> Maybe Text
expectedRevisionId :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the bot or bot alias that the resource
    -- policy is attached to.
    CreateResourcePolicyStatement -> Text
resourceArn :: Prelude.Text,
    -- | The name of the statement. The ID is the same as the @Sid@ IAM property.
    -- The statement name must be unique within the policy. For more
    -- information, see
    -- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_sid.html IAM JSON policy elements: Sid>.
    CreateResourcePolicyStatement -> Text
statementId :: Prelude.Text,
    -- | Determines whether the statement allows or denies access to the
    -- resource.
    CreateResourcePolicyStatement -> Effect
effect :: Effect,
    -- | An IAM principal, such as an IAM users, IAM roles, or AWS services that
    -- is allowed or denied access to a resource. For more information, see
    -- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html AWS JSON policy elements: Principal>.
    CreateResourcePolicyStatement -> [Principal]
principal :: [Principal],
    -- | The Amazon Lex action that this policy either allows or denies. The
    -- action must apply to the resource type of the specified ARN. For more
    -- information, see
    -- <https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlexv2.html Actions, resources, and condition keys for Amazon Lex V2>.
    CreateResourcePolicyStatement -> [Text]
action :: [Prelude.Text]
  }
  deriving (CreateResourcePolicyStatement
-> CreateResourcePolicyStatement -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateResourcePolicyStatement
-> CreateResourcePolicyStatement -> Bool
$c/= :: CreateResourcePolicyStatement
-> CreateResourcePolicyStatement -> Bool
== :: CreateResourcePolicyStatement
-> CreateResourcePolicyStatement -> Bool
$c== :: CreateResourcePolicyStatement
-> CreateResourcePolicyStatement -> Bool
Prelude.Eq, ReadPrec [CreateResourcePolicyStatement]
ReadPrec CreateResourcePolicyStatement
Int -> ReadS CreateResourcePolicyStatement
ReadS [CreateResourcePolicyStatement]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateResourcePolicyStatement]
$creadListPrec :: ReadPrec [CreateResourcePolicyStatement]
readPrec :: ReadPrec CreateResourcePolicyStatement
$creadPrec :: ReadPrec CreateResourcePolicyStatement
readList :: ReadS [CreateResourcePolicyStatement]
$creadList :: ReadS [CreateResourcePolicyStatement]
readsPrec :: Int -> ReadS CreateResourcePolicyStatement
$creadsPrec :: Int -> ReadS CreateResourcePolicyStatement
Prelude.Read, Int -> CreateResourcePolicyStatement -> ShowS
[CreateResourcePolicyStatement] -> ShowS
CreateResourcePolicyStatement -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateResourcePolicyStatement] -> ShowS
$cshowList :: [CreateResourcePolicyStatement] -> ShowS
show :: CreateResourcePolicyStatement -> String
$cshow :: CreateResourcePolicyStatement -> String
showsPrec :: Int -> CreateResourcePolicyStatement -> ShowS
$cshowsPrec :: Int -> CreateResourcePolicyStatement -> ShowS
Prelude.Show, forall x.
Rep CreateResourcePolicyStatement x
-> CreateResourcePolicyStatement
forall x.
CreateResourcePolicyStatement
-> Rep CreateResourcePolicyStatement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateResourcePolicyStatement x
-> CreateResourcePolicyStatement
$cfrom :: forall x.
CreateResourcePolicyStatement
-> Rep CreateResourcePolicyStatement x
Prelude.Generic)

-- |
-- Create a value of 'CreateResourcePolicyStatement' 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:
--
-- 'condition', 'createResourcePolicyStatement_condition' - Specifies a condition when the policy is in effect. If the principal of
-- the policy is a service principal, you must provide two condition
-- blocks, one with a SourceAccount global condition key and one with a
-- SourceArn global condition key.
--
-- For more information, see
-- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html IAM JSON policy elements: Condition>
-- .
--
-- 'expectedRevisionId', 'createResourcePolicyStatement_expectedRevisionId' - The identifier of the revision of the policy to edit. If this revision
-- ID doesn\'t match the current revision ID, Amazon Lex throws an
-- exception.
--
-- If you don\'t specify a revision, Amazon Lex overwrites the contents of
-- the policy with the new values.
--
-- 'resourceArn', 'createResourcePolicyStatement_resourceArn' - The Amazon Resource Name (ARN) of the bot or bot alias that the resource
-- policy is attached to.
--
-- 'statementId', 'createResourcePolicyStatement_statementId' - The name of the statement. The ID is the same as the @Sid@ IAM property.
-- The statement name must be unique within the policy. For more
-- information, see
-- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_sid.html IAM JSON policy elements: Sid>.
--
-- 'effect', 'createResourcePolicyStatement_effect' - Determines whether the statement allows or denies access to the
-- resource.
--
-- 'principal', 'createResourcePolicyStatement_principal' - An IAM principal, such as an IAM users, IAM roles, or AWS services that
-- is allowed or denied access to a resource. For more information, see
-- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html AWS JSON policy elements: Principal>.
--
-- 'action', 'createResourcePolicyStatement_action' - The Amazon Lex action that this policy either allows or denies. The
-- action must apply to the resource type of the specified ARN. For more
-- information, see
-- <https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlexv2.html Actions, resources, and condition keys for Amazon Lex V2>.
newCreateResourcePolicyStatement ::
  -- | 'resourceArn'
  Prelude.Text ->
  -- | 'statementId'
  Prelude.Text ->
  -- | 'effect'
  Effect ->
  CreateResourcePolicyStatement
newCreateResourcePolicyStatement :: Text -> Text -> Effect -> CreateResourcePolicyStatement
newCreateResourcePolicyStatement
  Text
pResourceArn_
  Text
pStatementId_
  Effect
pEffect_ =
    CreateResourcePolicyStatement'
      { $sel:condition:CreateResourcePolicyStatement' :: Maybe (HashMap Text (HashMap Text Text))
condition =
          forall a. Maybe a
Prelude.Nothing,
        $sel:expectedRevisionId:CreateResourcePolicyStatement' :: Maybe Text
expectedRevisionId = forall a. Maybe a
Prelude.Nothing,
        $sel:resourceArn:CreateResourcePolicyStatement' :: Text
resourceArn = Text
pResourceArn_,
        $sel:statementId:CreateResourcePolicyStatement' :: Text
statementId = Text
pStatementId_,
        $sel:effect:CreateResourcePolicyStatement' :: Effect
effect = Effect
pEffect_,
        $sel:principal:CreateResourcePolicyStatement' :: [Principal]
principal = forall a. Monoid a => a
Prelude.mempty,
        $sel:action:CreateResourcePolicyStatement' :: [Text]
action = forall a. Monoid a => a
Prelude.mempty
      }

-- | Specifies a condition when the policy is in effect. If the principal of
-- the policy is a service principal, you must provide two condition
-- blocks, one with a SourceAccount global condition key and one with a
-- SourceArn global condition key.
--
-- For more information, see
-- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html IAM JSON policy elements: Condition>
-- .
createResourcePolicyStatement_condition :: Lens.Lens' CreateResourcePolicyStatement (Prelude.Maybe (Prelude.HashMap Prelude.Text (Prelude.HashMap Prelude.Text Prelude.Text)))
createResourcePolicyStatement_condition :: Lens'
  CreateResourcePolicyStatement
  (Maybe (HashMap Text (HashMap Text Text)))
createResourcePolicyStatement_condition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourcePolicyStatement' {Maybe (HashMap Text (HashMap Text Text))
condition :: Maybe (HashMap Text (HashMap Text Text))
$sel:condition:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement
-> Maybe (HashMap Text (HashMap Text Text))
condition} -> Maybe (HashMap Text (HashMap Text Text))
condition) (\s :: CreateResourcePolicyStatement
s@CreateResourcePolicyStatement' {} Maybe (HashMap Text (HashMap Text Text))
a -> CreateResourcePolicyStatement
s {$sel:condition:CreateResourcePolicyStatement' :: Maybe (HashMap Text (HashMap Text Text))
condition = Maybe (HashMap Text (HashMap Text Text))
a} :: CreateResourcePolicyStatement) 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 identifier of the revision of the policy to edit. If this revision
-- ID doesn\'t match the current revision ID, Amazon Lex throws an
-- exception.
--
-- If you don\'t specify a revision, Amazon Lex overwrites the contents of
-- the policy with the new values.
createResourcePolicyStatement_expectedRevisionId :: Lens.Lens' CreateResourcePolicyStatement (Prelude.Maybe Prelude.Text)
createResourcePolicyStatement_expectedRevisionId :: Lens' CreateResourcePolicyStatement (Maybe Text)
createResourcePolicyStatement_expectedRevisionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourcePolicyStatement' {Maybe Text
expectedRevisionId :: Maybe Text
$sel:expectedRevisionId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Maybe Text
expectedRevisionId} -> Maybe Text
expectedRevisionId) (\s :: CreateResourcePolicyStatement
s@CreateResourcePolicyStatement' {} Maybe Text
a -> CreateResourcePolicyStatement
s {$sel:expectedRevisionId:CreateResourcePolicyStatement' :: Maybe Text
expectedRevisionId = Maybe Text
a} :: CreateResourcePolicyStatement)

-- | The Amazon Resource Name (ARN) of the bot or bot alias that the resource
-- policy is attached to.
createResourcePolicyStatement_resourceArn :: Lens.Lens' CreateResourcePolicyStatement Prelude.Text
createResourcePolicyStatement_resourceArn :: Lens' CreateResourcePolicyStatement Text
createResourcePolicyStatement_resourceArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourcePolicyStatement' {Text
resourceArn :: Text
$sel:resourceArn:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
resourceArn} -> Text
resourceArn) (\s :: CreateResourcePolicyStatement
s@CreateResourcePolicyStatement' {} Text
a -> CreateResourcePolicyStatement
s {$sel:resourceArn:CreateResourcePolicyStatement' :: Text
resourceArn = Text
a} :: CreateResourcePolicyStatement)

-- | The name of the statement. The ID is the same as the @Sid@ IAM property.
-- The statement name must be unique within the policy. For more
-- information, see
-- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_sid.html IAM JSON policy elements: Sid>.
createResourcePolicyStatement_statementId :: Lens.Lens' CreateResourcePolicyStatement Prelude.Text
createResourcePolicyStatement_statementId :: Lens' CreateResourcePolicyStatement Text
createResourcePolicyStatement_statementId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourcePolicyStatement' {Text
statementId :: Text
$sel:statementId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
statementId} -> Text
statementId) (\s :: CreateResourcePolicyStatement
s@CreateResourcePolicyStatement' {} Text
a -> CreateResourcePolicyStatement
s {$sel:statementId:CreateResourcePolicyStatement' :: Text
statementId = Text
a} :: CreateResourcePolicyStatement)

-- | Determines whether the statement allows or denies access to the
-- resource.
createResourcePolicyStatement_effect :: Lens.Lens' CreateResourcePolicyStatement Effect
createResourcePolicyStatement_effect :: Lens' CreateResourcePolicyStatement Effect
createResourcePolicyStatement_effect = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourcePolicyStatement' {Effect
effect :: Effect
$sel:effect:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Effect
effect} -> Effect
effect) (\s :: CreateResourcePolicyStatement
s@CreateResourcePolicyStatement' {} Effect
a -> CreateResourcePolicyStatement
s {$sel:effect:CreateResourcePolicyStatement' :: Effect
effect = Effect
a} :: CreateResourcePolicyStatement)

-- | An IAM principal, such as an IAM users, IAM roles, or AWS services that
-- is allowed or denied access to a resource. For more information, see
-- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html AWS JSON policy elements: Principal>.
createResourcePolicyStatement_principal :: Lens.Lens' CreateResourcePolicyStatement [Principal]
createResourcePolicyStatement_principal :: Lens' CreateResourcePolicyStatement [Principal]
createResourcePolicyStatement_principal = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourcePolicyStatement' {[Principal]
principal :: [Principal]
$sel:principal:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Principal]
principal} -> [Principal]
principal) (\s :: CreateResourcePolicyStatement
s@CreateResourcePolicyStatement' {} [Principal]
a -> CreateResourcePolicyStatement
s {$sel:principal:CreateResourcePolicyStatement' :: [Principal]
principal = [Principal]
a} :: CreateResourcePolicyStatement) 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

-- | The Amazon Lex action that this policy either allows or denies. The
-- action must apply to the resource type of the specified ARN. For more
-- information, see
-- <https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlexv2.html Actions, resources, and condition keys for Amazon Lex V2>.
createResourcePolicyStatement_action :: Lens.Lens' CreateResourcePolicyStatement [Prelude.Text]
createResourcePolicyStatement_action :: Lens' CreateResourcePolicyStatement [Text]
createResourcePolicyStatement_action = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourcePolicyStatement' {[Text]
action :: [Text]
$sel:action:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Text]
action} -> [Text]
action) (\s :: CreateResourcePolicyStatement
s@CreateResourcePolicyStatement' {} [Text]
a -> CreateResourcePolicyStatement
s {$sel:action:CreateResourcePolicyStatement' :: [Text]
action = [Text]
a} :: CreateResourcePolicyStatement) 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
    CreateResourcePolicyStatement
  where
  type
    AWSResponse CreateResourcePolicyStatement =
      CreateResourcePolicyStatementResponse
  request :: (Service -> Service)
-> CreateResourcePolicyStatement
-> Request CreateResourcePolicyStatement
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 CreateResourcePolicyStatement
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateResourcePolicyStatement)))
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 -> CreateResourcePolicyStatementResponse
CreateResourcePolicyStatementResponse'
            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
"resourceArn")
            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
"revisionId")
            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
    CreateResourcePolicyStatement
  where
  hashWithSalt :: Int -> CreateResourcePolicyStatement -> Int
hashWithSalt Int
_salt CreateResourcePolicyStatement' {[Text]
[Principal]
Maybe Text
Maybe (HashMap Text (HashMap Text Text))
Text
Effect
action :: [Text]
principal :: [Principal]
effect :: Effect
statementId :: Text
resourceArn :: Text
expectedRevisionId :: Maybe Text
condition :: Maybe (HashMap Text (HashMap Text Text))
$sel:action:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Text]
$sel:principal:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Principal]
$sel:effect:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Effect
$sel:statementId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:resourceArn:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:expectedRevisionId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Maybe Text
$sel:condition:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement
-> Maybe (HashMap Text (HashMap Text Text))
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text (HashMap Text Text))
condition
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
expectedRevisionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
resourceArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
statementId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Effect
effect
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Principal]
principal
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
action

instance Prelude.NFData CreateResourcePolicyStatement where
  rnf :: CreateResourcePolicyStatement -> ()
rnf CreateResourcePolicyStatement' {[Text]
[Principal]
Maybe Text
Maybe (HashMap Text (HashMap Text Text))
Text
Effect
action :: [Text]
principal :: [Principal]
effect :: Effect
statementId :: Text
resourceArn :: Text
expectedRevisionId :: Maybe Text
condition :: Maybe (HashMap Text (HashMap Text Text))
$sel:action:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Text]
$sel:principal:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Principal]
$sel:effect:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Effect
$sel:statementId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:resourceArn:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:expectedRevisionId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Maybe Text
$sel:condition:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement
-> Maybe (HashMap Text (HashMap Text Text))
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text (HashMap Text Text))
condition
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
expectedRevisionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
resourceArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
statementId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Effect
effect
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Principal]
principal
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
action

instance Data.ToHeaders CreateResourcePolicyStatement where
  toHeaders :: CreateResourcePolicyStatement -> 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 CreateResourcePolicyStatement where
  toJSON :: CreateResourcePolicyStatement -> Value
toJSON CreateResourcePolicyStatement' {[Text]
[Principal]
Maybe Text
Maybe (HashMap Text (HashMap Text Text))
Text
Effect
action :: [Text]
principal :: [Principal]
effect :: Effect
statementId :: Text
resourceArn :: Text
expectedRevisionId :: Maybe Text
condition :: Maybe (HashMap Text (HashMap Text Text))
$sel:action:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Text]
$sel:principal:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Principal]
$sel:effect:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Effect
$sel:statementId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:resourceArn:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:expectedRevisionId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Maybe Text
$sel:condition:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement
-> Maybe (HashMap Text (HashMap Text Text))
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"condition" 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 (HashMap Text (HashMap Text Text))
condition,
            forall a. a -> Maybe a
Prelude.Just (Key
"statementId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
statementId),
            forall a. a -> Maybe a
Prelude.Just (Key
"effect" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Effect
effect),
            forall a. a -> Maybe a
Prelude.Just (Key
"principal" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [Principal]
principal),
            forall a. a -> Maybe a
Prelude.Just (Key
"action" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [Text]
action)
          ]
      )

instance Data.ToPath CreateResourcePolicyStatement where
  toPath :: CreateResourcePolicyStatement -> ByteString
toPath CreateResourcePolicyStatement' {[Text]
[Principal]
Maybe Text
Maybe (HashMap Text (HashMap Text Text))
Text
Effect
action :: [Text]
principal :: [Principal]
effect :: Effect
statementId :: Text
resourceArn :: Text
expectedRevisionId :: Maybe Text
condition :: Maybe (HashMap Text (HashMap Text Text))
$sel:action:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Text]
$sel:principal:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Principal]
$sel:effect:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Effect
$sel:statementId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:resourceArn:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:expectedRevisionId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Maybe Text
$sel:condition:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement
-> Maybe (HashMap Text (HashMap Text Text))
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/policy/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
resourceArn, ByteString
"/statements/"]

instance Data.ToQuery CreateResourcePolicyStatement where
  toQuery :: CreateResourcePolicyStatement -> QueryString
toQuery CreateResourcePolicyStatement' {[Text]
[Principal]
Maybe Text
Maybe (HashMap Text (HashMap Text Text))
Text
Effect
action :: [Text]
principal :: [Principal]
effect :: Effect
statementId :: Text
resourceArn :: Text
expectedRevisionId :: Maybe Text
condition :: Maybe (HashMap Text (HashMap Text Text))
$sel:action:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Text]
$sel:principal:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> [Principal]
$sel:effect:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Effect
$sel:statementId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:resourceArn:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Text
$sel:expectedRevisionId:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement -> Maybe Text
$sel:condition:CreateResourcePolicyStatement' :: CreateResourcePolicyStatement
-> Maybe (HashMap Text (HashMap Text Text))
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"expectedRevisionId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
expectedRevisionId]

-- | /See:/ 'newCreateResourcePolicyStatementResponse' smart constructor.
data CreateResourcePolicyStatementResponse = CreateResourcePolicyStatementResponse'
  { -- | The Amazon Resource Name (ARN) of the bot or bot alias that the resource
    -- policy is attached to.
    CreateResourcePolicyStatementResponse -> Maybe Text
resourceArn :: Prelude.Maybe Prelude.Text,
    -- | The current revision of the resource policy. Use the revision ID to make
    -- sure that you are updating the most current version of a resource policy
    -- when you add a policy statement to a resource, delete a resource, or
    -- update a resource.
    CreateResourcePolicyStatementResponse -> Maybe Text
revisionId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreateResourcePolicyStatementResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateResourcePolicyStatementResponse
-> CreateResourcePolicyStatementResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateResourcePolicyStatementResponse
-> CreateResourcePolicyStatementResponse -> Bool
$c/= :: CreateResourcePolicyStatementResponse
-> CreateResourcePolicyStatementResponse -> Bool
== :: CreateResourcePolicyStatementResponse
-> CreateResourcePolicyStatementResponse -> Bool
$c== :: CreateResourcePolicyStatementResponse
-> CreateResourcePolicyStatementResponse -> Bool
Prelude.Eq, ReadPrec [CreateResourcePolicyStatementResponse]
ReadPrec CreateResourcePolicyStatementResponse
Int -> ReadS CreateResourcePolicyStatementResponse
ReadS [CreateResourcePolicyStatementResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateResourcePolicyStatementResponse]
$creadListPrec :: ReadPrec [CreateResourcePolicyStatementResponse]
readPrec :: ReadPrec CreateResourcePolicyStatementResponse
$creadPrec :: ReadPrec CreateResourcePolicyStatementResponse
readList :: ReadS [CreateResourcePolicyStatementResponse]
$creadList :: ReadS [CreateResourcePolicyStatementResponse]
readsPrec :: Int -> ReadS CreateResourcePolicyStatementResponse
$creadsPrec :: Int -> ReadS CreateResourcePolicyStatementResponse
Prelude.Read, Int -> CreateResourcePolicyStatementResponse -> ShowS
[CreateResourcePolicyStatementResponse] -> ShowS
CreateResourcePolicyStatementResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateResourcePolicyStatementResponse] -> ShowS
$cshowList :: [CreateResourcePolicyStatementResponse] -> ShowS
show :: CreateResourcePolicyStatementResponse -> String
$cshow :: CreateResourcePolicyStatementResponse -> String
showsPrec :: Int -> CreateResourcePolicyStatementResponse -> ShowS
$cshowsPrec :: Int -> CreateResourcePolicyStatementResponse -> ShowS
Prelude.Show, forall x.
Rep CreateResourcePolicyStatementResponse x
-> CreateResourcePolicyStatementResponse
forall x.
CreateResourcePolicyStatementResponse
-> Rep CreateResourcePolicyStatementResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateResourcePolicyStatementResponse x
-> CreateResourcePolicyStatementResponse
$cfrom :: forall x.
CreateResourcePolicyStatementResponse
-> Rep CreateResourcePolicyStatementResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateResourcePolicyStatementResponse' 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:
--
-- 'resourceArn', 'createResourcePolicyStatementResponse_resourceArn' - The Amazon Resource Name (ARN) of the bot or bot alias that the resource
-- policy is attached to.
--
-- 'revisionId', 'createResourcePolicyStatementResponse_revisionId' - The current revision of the resource policy. Use the revision ID to make
-- sure that you are updating the most current version of a resource policy
-- when you add a policy statement to a resource, delete a resource, or
-- update a resource.
--
-- 'httpStatus', 'createResourcePolicyStatementResponse_httpStatus' - The response's http status code.
newCreateResourcePolicyStatementResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateResourcePolicyStatementResponse
newCreateResourcePolicyStatementResponse :: Int -> CreateResourcePolicyStatementResponse
newCreateResourcePolicyStatementResponse Int
pHttpStatus_ =
  CreateResourcePolicyStatementResponse'
    { $sel:resourceArn:CreateResourcePolicyStatementResponse' :: Maybe Text
resourceArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:revisionId:CreateResourcePolicyStatementResponse' :: Maybe Text
revisionId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateResourcePolicyStatementResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Amazon Resource Name (ARN) of the bot or bot alias that the resource
-- policy is attached to.
createResourcePolicyStatementResponse_resourceArn :: Lens.Lens' CreateResourcePolicyStatementResponse (Prelude.Maybe Prelude.Text)
createResourcePolicyStatementResponse_resourceArn :: Lens' CreateResourcePolicyStatementResponse (Maybe Text)
createResourcePolicyStatementResponse_resourceArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourcePolicyStatementResponse' {Maybe Text
resourceArn :: Maybe Text
$sel:resourceArn:CreateResourcePolicyStatementResponse' :: CreateResourcePolicyStatementResponse -> Maybe Text
resourceArn} -> Maybe Text
resourceArn) (\s :: CreateResourcePolicyStatementResponse
s@CreateResourcePolicyStatementResponse' {} Maybe Text
a -> CreateResourcePolicyStatementResponse
s {$sel:resourceArn:CreateResourcePolicyStatementResponse' :: Maybe Text
resourceArn = Maybe Text
a} :: CreateResourcePolicyStatementResponse)

-- | The current revision of the resource policy. Use the revision ID to make
-- sure that you are updating the most current version of a resource policy
-- when you add a policy statement to a resource, delete a resource, or
-- update a resource.
createResourcePolicyStatementResponse_revisionId :: Lens.Lens' CreateResourcePolicyStatementResponse (Prelude.Maybe Prelude.Text)
createResourcePolicyStatementResponse_revisionId :: Lens' CreateResourcePolicyStatementResponse (Maybe Text)
createResourcePolicyStatementResponse_revisionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourcePolicyStatementResponse' {Maybe Text
revisionId :: Maybe Text
$sel:revisionId:CreateResourcePolicyStatementResponse' :: CreateResourcePolicyStatementResponse -> Maybe Text
revisionId} -> Maybe Text
revisionId) (\s :: CreateResourcePolicyStatementResponse
s@CreateResourcePolicyStatementResponse' {} Maybe Text
a -> CreateResourcePolicyStatementResponse
s {$sel:revisionId:CreateResourcePolicyStatementResponse' :: Maybe Text
revisionId = Maybe Text
a} :: CreateResourcePolicyStatementResponse)

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

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