{-# 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.AMP.CreateRuleGroupsNamespace
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Create a rule group namespace.
module Amazonka.AMP.CreateRuleGroupsNamespace
  ( -- * Creating a Request
    CreateRuleGroupsNamespace (..),
    newCreateRuleGroupsNamespace,

    -- * Request Lenses
    createRuleGroupsNamespace_clientToken,
    createRuleGroupsNamespace_tags,
    createRuleGroupsNamespace_data,
    createRuleGroupsNamespace_name,
    createRuleGroupsNamespace_workspaceId,

    -- * Destructuring the Response
    CreateRuleGroupsNamespaceResponse (..),
    newCreateRuleGroupsNamespaceResponse,

    -- * Response Lenses
    createRuleGroupsNamespaceResponse_tags,
    createRuleGroupsNamespaceResponse_httpStatus,
    createRuleGroupsNamespaceResponse_arn,
    createRuleGroupsNamespaceResponse_name,
    createRuleGroupsNamespaceResponse_status,
  )
where

import Amazonka.AMP.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

-- | Represents the input of a CreateRuleGroupsNamespace operation.
--
-- /See:/ 'newCreateRuleGroupsNamespace' smart constructor.
data CreateRuleGroupsNamespace = CreateRuleGroupsNamespace'
  { -- | Optional, unique, case-sensitive, user-provided identifier to ensure the
    -- idempotency of the request.
    CreateRuleGroupsNamespace -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | Optional, user-provided tags for this rule groups namespace.
    CreateRuleGroupsNamespace -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The namespace data that define the rule groups.
    CreateRuleGroupsNamespace -> Base64
data' :: Data.Base64,
    -- | The rule groups namespace name.
    CreateRuleGroupsNamespace -> Text
name :: Prelude.Text,
    -- | The ID of the workspace in which to create the rule group namespace.
    CreateRuleGroupsNamespace -> Text
workspaceId :: Prelude.Text
  }
  deriving (CreateRuleGroupsNamespace -> CreateRuleGroupsNamespace -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRuleGroupsNamespace -> CreateRuleGroupsNamespace -> Bool
$c/= :: CreateRuleGroupsNamespace -> CreateRuleGroupsNamespace -> Bool
== :: CreateRuleGroupsNamespace -> CreateRuleGroupsNamespace -> Bool
$c== :: CreateRuleGroupsNamespace -> CreateRuleGroupsNamespace -> Bool
Prelude.Eq, ReadPrec [CreateRuleGroupsNamespace]
ReadPrec CreateRuleGroupsNamespace
Int -> ReadS CreateRuleGroupsNamespace
ReadS [CreateRuleGroupsNamespace]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRuleGroupsNamespace]
$creadListPrec :: ReadPrec [CreateRuleGroupsNamespace]
readPrec :: ReadPrec CreateRuleGroupsNamespace
$creadPrec :: ReadPrec CreateRuleGroupsNamespace
readList :: ReadS [CreateRuleGroupsNamespace]
$creadList :: ReadS [CreateRuleGroupsNamespace]
readsPrec :: Int -> ReadS CreateRuleGroupsNamespace
$creadsPrec :: Int -> ReadS CreateRuleGroupsNamespace
Prelude.Read, Int -> CreateRuleGroupsNamespace -> ShowS
[CreateRuleGroupsNamespace] -> ShowS
CreateRuleGroupsNamespace -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRuleGroupsNamespace] -> ShowS
$cshowList :: [CreateRuleGroupsNamespace] -> ShowS
show :: CreateRuleGroupsNamespace -> String
$cshow :: CreateRuleGroupsNamespace -> String
showsPrec :: Int -> CreateRuleGroupsNamespace -> ShowS
$cshowsPrec :: Int -> CreateRuleGroupsNamespace -> ShowS
Prelude.Show, forall x.
Rep CreateRuleGroupsNamespace x -> CreateRuleGroupsNamespace
forall x.
CreateRuleGroupsNamespace -> Rep CreateRuleGroupsNamespace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateRuleGroupsNamespace x -> CreateRuleGroupsNamespace
$cfrom :: forall x.
CreateRuleGroupsNamespace -> Rep CreateRuleGroupsNamespace x
Prelude.Generic)

-- |
-- Create a value of 'CreateRuleGroupsNamespace' 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:
--
-- 'clientToken', 'createRuleGroupsNamespace_clientToken' - Optional, unique, case-sensitive, user-provided identifier to ensure the
-- idempotency of the request.
--
-- 'tags', 'createRuleGroupsNamespace_tags' - Optional, user-provided tags for this rule groups namespace.
--
-- 'data'', 'createRuleGroupsNamespace_data' - The namespace data that define the rule groups.--
-- -- /Note:/ This 'Lens' automatically encodes and decodes Base64 data.
-- -- The underlying isomorphism will encode to Base64 representation during
-- -- serialisation, and decode from Base64 representation during deserialisation.
-- -- This 'Lens' accepts and returns only raw unencoded data.
--
-- 'name', 'createRuleGroupsNamespace_name' - The rule groups namespace name.
--
-- 'workspaceId', 'createRuleGroupsNamespace_workspaceId' - The ID of the workspace in which to create the rule group namespace.
newCreateRuleGroupsNamespace ::
  -- | 'data''
  Prelude.ByteString ->
  -- | 'name'
  Prelude.Text ->
  -- | 'workspaceId'
  Prelude.Text ->
  CreateRuleGroupsNamespace
newCreateRuleGroupsNamespace :: ByteString -> Text -> Text -> CreateRuleGroupsNamespace
newCreateRuleGroupsNamespace
  ByteString
pData_
  Text
pName_
  Text
pWorkspaceId_ =
    CreateRuleGroupsNamespace'
      { $sel:clientToken:CreateRuleGroupsNamespace' :: Maybe Text
clientToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateRuleGroupsNamespace' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:data':CreateRuleGroupsNamespace' :: Base64
data' = Iso' Base64 ByteString
Data._Base64 forall t b. AReview t b -> b -> t
Lens.# ByteString
pData_,
        $sel:name:CreateRuleGroupsNamespace' :: Text
name = Text
pName_,
        $sel:workspaceId:CreateRuleGroupsNamespace' :: Text
workspaceId = Text
pWorkspaceId_
      }

-- | Optional, unique, case-sensitive, user-provided identifier to ensure the
-- idempotency of the request.
createRuleGroupsNamespace_clientToken :: Lens.Lens' CreateRuleGroupsNamespace (Prelude.Maybe Prelude.Text)
createRuleGroupsNamespace_clientToken :: Lens' CreateRuleGroupsNamespace (Maybe Text)
createRuleGroupsNamespace_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespace' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateRuleGroupsNamespace
s@CreateRuleGroupsNamespace' {} Maybe Text
a -> CreateRuleGroupsNamespace
s {$sel:clientToken:CreateRuleGroupsNamespace' :: Maybe Text
clientToken = Maybe Text
a} :: CreateRuleGroupsNamespace)

-- | Optional, user-provided tags for this rule groups namespace.
createRuleGroupsNamespace_tags :: Lens.Lens' CreateRuleGroupsNamespace (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createRuleGroupsNamespace_tags :: Lens' CreateRuleGroupsNamespace (Maybe (HashMap Text Text))
createRuleGroupsNamespace_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespace' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateRuleGroupsNamespace
s@CreateRuleGroupsNamespace' {} Maybe (HashMap Text Text)
a -> CreateRuleGroupsNamespace
s {$sel:tags:CreateRuleGroupsNamespace' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateRuleGroupsNamespace) 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 namespace data that define the rule groups.--
-- -- /Note:/ This 'Lens' automatically encodes and decodes Base64 data.
-- -- The underlying isomorphism will encode to Base64 representation during
-- -- serialisation, and decode from Base64 representation during deserialisation.
-- -- This 'Lens' accepts and returns only raw unencoded data.
createRuleGroupsNamespace_data :: Lens.Lens' CreateRuleGroupsNamespace Prelude.ByteString
createRuleGroupsNamespace_data :: Lens' CreateRuleGroupsNamespace ByteString
createRuleGroupsNamespace_data = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespace' {Base64
data' :: Base64
$sel:data':CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Base64
data'} -> Base64
data') (\s :: CreateRuleGroupsNamespace
s@CreateRuleGroupsNamespace' {} Base64
a -> CreateRuleGroupsNamespace
s {$sel:data':CreateRuleGroupsNamespace' :: Base64
data' = Base64
a} :: CreateRuleGroupsNamespace) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. Iso' Base64 ByteString
Data._Base64

-- | The rule groups namespace name.
createRuleGroupsNamespace_name :: Lens.Lens' CreateRuleGroupsNamespace Prelude.Text
createRuleGroupsNamespace_name :: Lens' CreateRuleGroupsNamespace Text
createRuleGroupsNamespace_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespace' {Text
name :: Text
$sel:name:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
name} -> Text
name) (\s :: CreateRuleGroupsNamespace
s@CreateRuleGroupsNamespace' {} Text
a -> CreateRuleGroupsNamespace
s {$sel:name:CreateRuleGroupsNamespace' :: Text
name = Text
a} :: CreateRuleGroupsNamespace)

-- | The ID of the workspace in which to create the rule group namespace.
createRuleGroupsNamespace_workspaceId :: Lens.Lens' CreateRuleGroupsNamespace Prelude.Text
createRuleGroupsNamespace_workspaceId :: Lens' CreateRuleGroupsNamespace Text
createRuleGroupsNamespace_workspaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespace' {Text
workspaceId :: Text
$sel:workspaceId:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
workspaceId} -> Text
workspaceId) (\s :: CreateRuleGroupsNamespace
s@CreateRuleGroupsNamespace' {} Text
a -> CreateRuleGroupsNamespace
s {$sel:workspaceId:CreateRuleGroupsNamespace' :: Text
workspaceId = Text
a} :: CreateRuleGroupsNamespace)

instance Core.AWSRequest CreateRuleGroupsNamespace where
  type
    AWSResponse CreateRuleGroupsNamespace =
      CreateRuleGroupsNamespaceResponse
  request :: (Service -> Service)
-> CreateRuleGroupsNamespace -> Request CreateRuleGroupsNamespace
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 CreateRuleGroupsNamespace
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateRuleGroupsNamespace)))
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 (HashMap Text Text)
-> Int
-> Text
-> Text
-> RuleGroupsNamespaceStatus
-> CreateRuleGroupsNamespaceResponse
CreateRuleGroupsNamespaceResponse'
            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
"tags" 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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"arn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"status")
      )

instance Prelude.Hashable CreateRuleGroupsNamespace where
  hashWithSalt :: Int -> CreateRuleGroupsNamespace -> Int
hashWithSalt Int
_salt CreateRuleGroupsNamespace' {Maybe Text
Maybe (HashMap Text Text)
Text
Base64
workspaceId :: Text
name :: Text
data' :: Base64
tags :: Maybe (HashMap Text Text)
clientToken :: Maybe Text
$sel:workspaceId:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
$sel:name:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
$sel:data':CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Base64
$sel:tags:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe (HashMap Text Text)
$sel:clientToken:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Base64
data'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
workspaceId

instance Prelude.NFData CreateRuleGroupsNamespace where
  rnf :: CreateRuleGroupsNamespace -> ()
rnf CreateRuleGroupsNamespace' {Maybe Text
Maybe (HashMap Text Text)
Text
Base64
workspaceId :: Text
name :: Text
data' :: Base64
tags :: Maybe (HashMap Text Text)
clientToken :: Maybe Text
$sel:workspaceId:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
$sel:name:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
$sel:data':CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Base64
$sel:tags:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe (HashMap Text Text)
$sel:clientToken:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Base64
data'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
workspaceId

instance Data.ToHeaders CreateRuleGroupsNamespace where
  toHeaders :: CreateRuleGroupsNamespace -> 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 CreateRuleGroupsNamespace where
  toJSON :: CreateRuleGroupsNamespace -> Value
toJSON CreateRuleGroupsNamespace' {Maybe Text
Maybe (HashMap Text Text)
Text
Base64
workspaceId :: Text
name :: Text
data' :: Base64
tags :: Maybe (HashMap Text Text)
clientToken :: Maybe Text
$sel:workspaceId:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
$sel:name:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
$sel:data':CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Base64
$sel:tags:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe (HashMap Text Text)
$sel:clientToken:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"clientToken" 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
clientToken,
            (Key
"tags" 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 Text)
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"data" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Base64
data'),
            forall a. a -> Maybe a
Prelude.Just (Key
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)
          ]
      )

instance Data.ToPath CreateRuleGroupsNamespace where
  toPath :: CreateRuleGroupsNamespace -> ByteString
toPath CreateRuleGroupsNamespace' {Maybe Text
Maybe (HashMap Text Text)
Text
Base64
workspaceId :: Text
name :: Text
data' :: Base64
tags :: Maybe (HashMap Text Text)
clientToken :: Maybe Text
$sel:workspaceId:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
$sel:name:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Text
$sel:data':CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Base64
$sel:tags:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe (HashMap Text Text)
$sel:clientToken:CreateRuleGroupsNamespace' :: CreateRuleGroupsNamespace -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/workspaces/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
workspaceId,
        ByteString
"/rulegroupsnamespaces"
      ]

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

-- | Represents the output of a CreateRuleGroupsNamespace operation.
--
-- /See:/ 'newCreateRuleGroupsNamespaceResponse' smart constructor.
data CreateRuleGroupsNamespaceResponse = CreateRuleGroupsNamespaceResponse'
  { -- | The tags of this rule groups namespace.
    CreateRuleGroupsNamespaceResponse -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The response's http status code.
    CreateRuleGroupsNamespaceResponse -> Int
httpStatus :: Prelude.Int,
    -- | The Amazon Resource Name (ARN) of this rule groups namespace.
    CreateRuleGroupsNamespaceResponse -> Text
arn :: Prelude.Text,
    -- | The rule groups namespace name.
    CreateRuleGroupsNamespaceResponse -> Text
name :: Prelude.Text,
    -- | The status of rule groups namespace.
    CreateRuleGroupsNamespaceResponse -> RuleGroupsNamespaceStatus
status :: RuleGroupsNamespaceStatus
  }
  deriving (CreateRuleGroupsNamespaceResponse
-> CreateRuleGroupsNamespaceResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRuleGroupsNamespaceResponse
-> CreateRuleGroupsNamespaceResponse -> Bool
$c/= :: CreateRuleGroupsNamespaceResponse
-> CreateRuleGroupsNamespaceResponse -> Bool
== :: CreateRuleGroupsNamespaceResponse
-> CreateRuleGroupsNamespaceResponse -> Bool
$c== :: CreateRuleGroupsNamespaceResponse
-> CreateRuleGroupsNamespaceResponse -> Bool
Prelude.Eq, ReadPrec [CreateRuleGroupsNamespaceResponse]
ReadPrec CreateRuleGroupsNamespaceResponse
Int -> ReadS CreateRuleGroupsNamespaceResponse
ReadS [CreateRuleGroupsNamespaceResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRuleGroupsNamespaceResponse]
$creadListPrec :: ReadPrec [CreateRuleGroupsNamespaceResponse]
readPrec :: ReadPrec CreateRuleGroupsNamespaceResponse
$creadPrec :: ReadPrec CreateRuleGroupsNamespaceResponse
readList :: ReadS [CreateRuleGroupsNamespaceResponse]
$creadList :: ReadS [CreateRuleGroupsNamespaceResponse]
readsPrec :: Int -> ReadS CreateRuleGroupsNamespaceResponse
$creadsPrec :: Int -> ReadS CreateRuleGroupsNamespaceResponse
Prelude.Read, Int -> CreateRuleGroupsNamespaceResponse -> ShowS
[CreateRuleGroupsNamespaceResponse] -> ShowS
CreateRuleGroupsNamespaceResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRuleGroupsNamespaceResponse] -> ShowS
$cshowList :: [CreateRuleGroupsNamespaceResponse] -> ShowS
show :: CreateRuleGroupsNamespaceResponse -> String
$cshow :: CreateRuleGroupsNamespaceResponse -> String
showsPrec :: Int -> CreateRuleGroupsNamespaceResponse -> ShowS
$cshowsPrec :: Int -> CreateRuleGroupsNamespaceResponse -> ShowS
Prelude.Show, forall x.
Rep CreateRuleGroupsNamespaceResponse x
-> CreateRuleGroupsNamespaceResponse
forall x.
CreateRuleGroupsNamespaceResponse
-> Rep CreateRuleGroupsNamespaceResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateRuleGroupsNamespaceResponse x
-> CreateRuleGroupsNamespaceResponse
$cfrom :: forall x.
CreateRuleGroupsNamespaceResponse
-> Rep CreateRuleGroupsNamespaceResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateRuleGroupsNamespaceResponse' 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:
--
-- 'tags', 'createRuleGroupsNamespaceResponse_tags' - The tags of this rule groups namespace.
--
-- 'httpStatus', 'createRuleGroupsNamespaceResponse_httpStatus' - The response's http status code.
--
-- 'arn', 'createRuleGroupsNamespaceResponse_arn' - The Amazon Resource Name (ARN) of this rule groups namespace.
--
-- 'name', 'createRuleGroupsNamespaceResponse_name' - The rule groups namespace name.
--
-- 'status', 'createRuleGroupsNamespaceResponse_status' - The status of rule groups namespace.
newCreateRuleGroupsNamespaceResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'arn'
  Prelude.Text ->
  -- | 'name'
  Prelude.Text ->
  -- | 'status'
  RuleGroupsNamespaceStatus ->
  CreateRuleGroupsNamespaceResponse
newCreateRuleGroupsNamespaceResponse :: Int
-> Text
-> Text
-> RuleGroupsNamespaceStatus
-> CreateRuleGroupsNamespaceResponse
newCreateRuleGroupsNamespaceResponse
  Int
pHttpStatus_
  Text
pArn_
  Text
pName_
  RuleGroupsNamespaceStatus
pStatus_ =
    CreateRuleGroupsNamespaceResponse'
      { $sel:tags:CreateRuleGroupsNamespaceResponse' :: Maybe (HashMap Text Text)
tags =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateRuleGroupsNamespaceResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:arn:CreateRuleGroupsNamespaceResponse' :: Text
arn = Text
pArn_,
        $sel:name:CreateRuleGroupsNamespaceResponse' :: Text
name = Text
pName_,
        $sel:status:CreateRuleGroupsNamespaceResponse' :: RuleGroupsNamespaceStatus
status = RuleGroupsNamespaceStatus
pStatus_
      }

-- | The tags of this rule groups namespace.
createRuleGroupsNamespaceResponse_tags :: Lens.Lens' CreateRuleGroupsNamespaceResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createRuleGroupsNamespaceResponse_tags :: Lens' CreateRuleGroupsNamespaceResponse (Maybe (HashMap Text Text))
createRuleGroupsNamespaceResponse_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespaceResponse' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateRuleGroupsNamespaceResponse
s@CreateRuleGroupsNamespaceResponse' {} Maybe (HashMap Text Text)
a -> CreateRuleGroupsNamespaceResponse
s {$sel:tags:CreateRuleGroupsNamespaceResponse' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateRuleGroupsNamespaceResponse) 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.
createRuleGroupsNamespaceResponse_httpStatus :: Lens.Lens' CreateRuleGroupsNamespaceResponse Prelude.Int
createRuleGroupsNamespaceResponse_httpStatus :: Lens' CreateRuleGroupsNamespaceResponse Int
createRuleGroupsNamespaceResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespaceResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateRuleGroupsNamespaceResponse
s@CreateRuleGroupsNamespaceResponse' {} Int
a -> CreateRuleGroupsNamespaceResponse
s {$sel:httpStatus:CreateRuleGroupsNamespaceResponse' :: Int
httpStatus = Int
a} :: CreateRuleGroupsNamespaceResponse)

-- | The Amazon Resource Name (ARN) of this rule groups namespace.
createRuleGroupsNamespaceResponse_arn :: Lens.Lens' CreateRuleGroupsNamespaceResponse Prelude.Text
createRuleGroupsNamespaceResponse_arn :: Lens' CreateRuleGroupsNamespaceResponse Text
createRuleGroupsNamespaceResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespaceResponse' {Text
arn :: Text
$sel:arn:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> Text
arn} -> Text
arn) (\s :: CreateRuleGroupsNamespaceResponse
s@CreateRuleGroupsNamespaceResponse' {} Text
a -> CreateRuleGroupsNamespaceResponse
s {$sel:arn:CreateRuleGroupsNamespaceResponse' :: Text
arn = Text
a} :: CreateRuleGroupsNamespaceResponse)

-- | The rule groups namespace name.
createRuleGroupsNamespaceResponse_name :: Lens.Lens' CreateRuleGroupsNamespaceResponse Prelude.Text
createRuleGroupsNamespaceResponse_name :: Lens' CreateRuleGroupsNamespaceResponse Text
createRuleGroupsNamespaceResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespaceResponse' {Text
name :: Text
$sel:name:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> Text
name} -> Text
name) (\s :: CreateRuleGroupsNamespaceResponse
s@CreateRuleGroupsNamespaceResponse' {} Text
a -> CreateRuleGroupsNamespaceResponse
s {$sel:name:CreateRuleGroupsNamespaceResponse' :: Text
name = Text
a} :: CreateRuleGroupsNamespaceResponse)

-- | The status of rule groups namespace.
createRuleGroupsNamespaceResponse_status :: Lens.Lens' CreateRuleGroupsNamespaceResponse RuleGroupsNamespaceStatus
createRuleGroupsNamespaceResponse_status :: Lens' CreateRuleGroupsNamespaceResponse RuleGroupsNamespaceStatus
createRuleGroupsNamespaceResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleGroupsNamespaceResponse' {RuleGroupsNamespaceStatus
status :: RuleGroupsNamespaceStatus
$sel:status:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> RuleGroupsNamespaceStatus
status} -> RuleGroupsNamespaceStatus
status) (\s :: CreateRuleGroupsNamespaceResponse
s@CreateRuleGroupsNamespaceResponse' {} RuleGroupsNamespaceStatus
a -> CreateRuleGroupsNamespaceResponse
s {$sel:status:CreateRuleGroupsNamespaceResponse' :: RuleGroupsNamespaceStatus
status = RuleGroupsNamespaceStatus
a} :: CreateRuleGroupsNamespaceResponse)

instance
  Prelude.NFData
    CreateRuleGroupsNamespaceResponse
  where
  rnf :: CreateRuleGroupsNamespaceResponse -> ()
rnf CreateRuleGroupsNamespaceResponse' {Int
Maybe (HashMap Text Text)
Text
RuleGroupsNamespaceStatus
status :: RuleGroupsNamespaceStatus
name :: Text
arn :: Text
httpStatus :: Int
tags :: Maybe (HashMap Text Text)
$sel:status:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> RuleGroupsNamespaceStatus
$sel:name:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> Text
$sel:arn:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> Text
$sel:httpStatus:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> Int
$sel:tags:CreateRuleGroupsNamespaceResponse' :: CreateRuleGroupsNamespaceResponse -> Maybe (HashMap Text Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf RuleGroupsNamespaceStatus
status