{-# 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.FraudDetector.UpdateRuleVersion
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Updates a rule version resulting in a new rule version. Updates a rule
-- version resulting in a new rule version (version 1, 2, 3 ...).
module Amazonka.FraudDetector.UpdateRuleVersion
  ( -- * Creating a Request
    UpdateRuleVersion (..),
    newUpdateRuleVersion,

    -- * Request Lenses
    updateRuleVersion_description,
    updateRuleVersion_tags,
    updateRuleVersion_rule,
    updateRuleVersion_expression,
    updateRuleVersion_language,
    updateRuleVersion_outcomes,

    -- * Destructuring the Response
    UpdateRuleVersionResponse (..),
    newUpdateRuleVersionResponse,

    -- * Response Lenses
    updateRuleVersionResponse_rule,
    updateRuleVersionResponse_httpStatus,
  )
where

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

-- | /See:/ 'newUpdateRuleVersion' smart constructor.
data UpdateRuleVersion = UpdateRuleVersion'
  { -- | The description.
    UpdateRuleVersion -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The tags to assign to the rule version.
    UpdateRuleVersion -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The rule to update.
    UpdateRuleVersion -> Rule
rule :: Rule,
    -- | The rule expression.
    UpdateRuleVersion -> Sensitive Text
expression :: Data.Sensitive Prelude.Text,
    -- | The language.
    UpdateRuleVersion -> Language
language :: Language,
    -- | The outcomes.
    UpdateRuleVersion -> NonEmpty Text
outcomes :: Prelude.NonEmpty Prelude.Text
  }
  deriving (UpdateRuleVersion -> UpdateRuleVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateRuleVersion -> UpdateRuleVersion -> Bool
$c/= :: UpdateRuleVersion -> UpdateRuleVersion -> Bool
== :: UpdateRuleVersion -> UpdateRuleVersion -> Bool
$c== :: UpdateRuleVersion -> UpdateRuleVersion -> Bool
Prelude.Eq, Int -> UpdateRuleVersion -> ShowS
[UpdateRuleVersion] -> ShowS
UpdateRuleVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateRuleVersion] -> ShowS
$cshowList :: [UpdateRuleVersion] -> ShowS
show :: UpdateRuleVersion -> String
$cshow :: UpdateRuleVersion -> String
showsPrec :: Int -> UpdateRuleVersion -> ShowS
$cshowsPrec :: Int -> UpdateRuleVersion -> ShowS
Prelude.Show, forall x. Rep UpdateRuleVersion x -> UpdateRuleVersion
forall x. UpdateRuleVersion -> Rep UpdateRuleVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateRuleVersion x -> UpdateRuleVersion
$cfrom :: forall x. UpdateRuleVersion -> Rep UpdateRuleVersion x
Prelude.Generic)

-- |
-- Create a value of 'UpdateRuleVersion' 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:
--
-- 'description', 'updateRuleVersion_description' - The description.
--
-- 'tags', 'updateRuleVersion_tags' - The tags to assign to the rule version.
--
-- 'rule', 'updateRuleVersion_rule' - The rule to update.
--
-- 'expression', 'updateRuleVersion_expression' - The rule expression.
--
-- 'language', 'updateRuleVersion_language' - The language.
--
-- 'outcomes', 'updateRuleVersion_outcomes' - The outcomes.
newUpdateRuleVersion ::
  -- | 'rule'
  Rule ->
  -- | 'expression'
  Prelude.Text ->
  -- | 'language'
  Language ->
  -- | 'outcomes'
  Prelude.NonEmpty Prelude.Text ->
  UpdateRuleVersion
newUpdateRuleVersion :: Rule -> Text -> Language -> NonEmpty Text -> UpdateRuleVersion
newUpdateRuleVersion
  Rule
pRule_
  Text
pExpression_
  Language
pLanguage_
  NonEmpty Text
pOutcomes_ =
    UpdateRuleVersion'
      { $sel:description:UpdateRuleVersion' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:UpdateRuleVersion' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:rule:UpdateRuleVersion' :: Rule
rule = Rule
pRule_,
        $sel:expression:UpdateRuleVersion' :: Sensitive Text
expression = forall a. Iso' (Sensitive a) a
Data._Sensitive forall t b. AReview t b -> b -> t
Lens.# Text
pExpression_,
        $sel:language:UpdateRuleVersion' :: Language
language = Language
pLanguage_,
        $sel:outcomes:UpdateRuleVersion' :: NonEmpty Text
outcomes = 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
pOutcomes_
      }

-- | The description.
updateRuleVersion_description :: Lens.Lens' UpdateRuleVersion (Prelude.Maybe Prelude.Text)
updateRuleVersion_description :: Lens' UpdateRuleVersion (Maybe Text)
updateRuleVersion_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateRuleVersion' {Maybe Text
description :: Maybe Text
$sel:description:UpdateRuleVersion' :: UpdateRuleVersion -> Maybe Text
description} -> Maybe Text
description) (\s :: UpdateRuleVersion
s@UpdateRuleVersion' {} Maybe Text
a -> UpdateRuleVersion
s {$sel:description:UpdateRuleVersion' :: Maybe Text
description = Maybe Text
a} :: UpdateRuleVersion)

-- | The tags to assign to the rule version.
updateRuleVersion_tags :: Lens.Lens' UpdateRuleVersion (Prelude.Maybe [Tag])
updateRuleVersion_tags :: Lens' UpdateRuleVersion (Maybe [Tag])
updateRuleVersion_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateRuleVersion' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:UpdateRuleVersion' :: UpdateRuleVersion -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: UpdateRuleVersion
s@UpdateRuleVersion' {} Maybe [Tag]
a -> UpdateRuleVersion
s {$sel:tags:UpdateRuleVersion' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: UpdateRuleVersion) 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 rule to update.
updateRuleVersion_rule :: Lens.Lens' UpdateRuleVersion Rule
updateRuleVersion_rule :: Lens' UpdateRuleVersion Rule
updateRuleVersion_rule = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateRuleVersion' {Rule
rule :: Rule
$sel:rule:UpdateRuleVersion' :: UpdateRuleVersion -> Rule
rule} -> Rule
rule) (\s :: UpdateRuleVersion
s@UpdateRuleVersion' {} Rule
a -> UpdateRuleVersion
s {$sel:rule:UpdateRuleVersion' :: Rule
rule = Rule
a} :: UpdateRuleVersion)

-- | The rule expression.
updateRuleVersion_expression :: Lens.Lens' UpdateRuleVersion Prelude.Text
updateRuleVersion_expression :: Lens' UpdateRuleVersion Text
updateRuleVersion_expression = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateRuleVersion' {Sensitive Text
expression :: Sensitive Text
$sel:expression:UpdateRuleVersion' :: UpdateRuleVersion -> Sensitive Text
expression} -> Sensitive Text
expression) (\s :: UpdateRuleVersion
s@UpdateRuleVersion' {} Sensitive Text
a -> UpdateRuleVersion
s {$sel:expression:UpdateRuleVersion' :: Sensitive Text
expression = Sensitive Text
a} :: UpdateRuleVersion) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a. Iso' (Sensitive a) a
Data._Sensitive

-- | The language.
updateRuleVersion_language :: Lens.Lens' UpdateRuleVersion Language
updateRuleVersion_language :: Lens' UpdateRuleVersion Language
updateRuleVersion_language = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateRuleVersion' {Language
language :: Language
$sel:language:UpdateRuleVersion' :: UpdateRuleVersion -> Language
language} -> Language
language) (\s :: UpdateRuleVersion
s@UpdateRuleVersion' {} Language
a -> UpdateRuleVersion
s {$sel:language:UpdateRuleVersion' :: Language
language = Language
a} :: UpdateRuleVersion)

-- | The outcomes.
updateRuleVersion_outcomes :: Lens.Lens' UpdateRuleVersion (Prelude.NonEmpty Prelude.Text)
updateRuleVersion_outcomes :: Lens' UpdateRuleVersion (NonEmpty Text)
updateRuleVersion_outcomes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateRuleVersion' {NonEmpty Text
outcomes :: NonEmpty Text
$sel:outcomes:UpdateRuleVersion' :: UpdateRuleVersion -> NonEmpty Text
outcomes} -> NonEmpty Text
outcomes) (\s :: UpdateRuleVersion
s@UpdateRuleVersion' {} NonEmpty Text
a -> UpdateRuleVersion
s {$sel:outcomes:UpdateRuleVersion' :: NonEmpty Text
outcomes = NonEmpty Text
a} :: UpdateRuleVersion) 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 UpdateRuleVersion where
  type
    AWSResponse UpdateRuleVersion =
      UpdateRuleVersionResponse
  request :: (Service -> Service)
-> UpdateRuleVersion -> Request UpdateRuleVersion
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 UpdateRuleVersion
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdateRuleVersion)))
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 Rule -> Int -> UpdateRuleVersionResponse
UpdateRuleVersionResponse'
            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
"rule")
            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 UpdateRuleVersion where
  hashWithSalt :: Int -> UpdateRuleVersion -> Int
hashWithSalt Int
_salt UpdateRuleVersion' {Maybe [Tag]
Maybe Text
NonEmpty Text
Sensitive Text
Language
Rule
outcomes :: NonEmpty Text
language :: Language
expression :: Sensitive Text
rule :: Rule
tags :: Maybe [Tag]
description :: Maybe Text
$sel:outcomes:UpdateRuleVersion' :: UpdateRuleVersion -> NonEmpty Text
$sel:language:UpdateRuleVersion' :: UpdateRuleVersion -> Language
$sel:expression:UpdateRuleVersion' :: UpdateRuleVersion -> Sensitive Text
$sel:rule:UpdateRuleVersion' :: UpdateRuleVersion -> Rule
$sel:tags:UpdateRuleVersion' :: UpdateRuleVersion -> Maybe [Tag]
$sel:description:UpdateRuleVersion' :: UpdateRuleVersion -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Rule
rule
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Sensitive Text
expression
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Language
language
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Text
outcomes

instance Prelude.NFData UpdateRuleVersion where
  rnf :: UpdateRuleVersion -> ()
rnf UpdateRuleVersion' {Maybe [Tag]
Maybe Text
NonEmpty Text
Sensitive Text
Language
Rule
outcomes :: NonEmpty Text
language :: Language
expression :: Sensitive Text
rule :: Rule
tags :: Maybe [Tag]
description :: Maybe Text
$sel:outcomes:UpdateRuleVersion' :: UpdateRuleVersion -> NonEmpty Text
$sel:language:UpdateRuleVersion' :: UpdateRuleVersion -> Language
$sel:expression:UpdateRuleVersion' :: UpdateRuleVersion -> Sensitive Text
$sel:rule:UpdateRuleVersion' :: UpdateRuleVersion -> Rule
$sel:tags:UpdateRuleVersion' :: UpdateRuleVersion -> Maybe [Tag]
$sel:description:UpdateRuleVersion' :: UpdateRuleVersion -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Rule
rule
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Sensitive Text
expression
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Language
language
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Text
outcomes

instance Data.ToHeaders UpdateRuleVersion where
  toHeaders :: UpdateRuleVersion -> 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
"AWSHawksNestServiceFacade.UpdateRuleVersion" ::
                          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 UpdateRuleVersion where
  toJSON :: UpdateRuleVersion -> Value
toJSON UpdateRuleVersion' {Maybe [Tag]
Maybe Text
NonEmpty Text
Sensitive Text
Language
Rule
outcomes :: NonEmpty Text
language :: Language
expression :: Sensitive Text
rule :: Rule
tags :: Maybe [Tag]
description :: Maybe Text
$sel:outcomes:UpdateRuleVersion' :: UpdateRuleVersion -> NonEmpty Text
$sel:language:UpdateRuleVersion' :: UpdateRuleVersion -> Language
$sel:expression:UpdateRuleVersion' :: UpdateRuleVersion -> Sensitive Text
$sel:rule:UpdateRuleVersion' :: UpdateRuleVersion -> Rule
$sel:tags:UpdateRuleVersion' :: UpdateRuleVersion -> Maybe [Tag]
$sel:description:UpdateRuleVersion' :: UpdateRuleVersion -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"description" 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
description,
            (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 [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"rule" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Rule
rule),
            forall a. a -> Maybe a
Prelude.Just (Key
"expression" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Sensitive Text
expression),
            forall a. a -> Maybe a
Prelude.Just (Key
"language" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Language
language),
            forall a. a -> Maybe a
Prelude.Just (Key
"outcomes" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Text
outcomes)
          ]
      )

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

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

-- | /See:/ 'newUpdateRuleVersionResponse' smart constructor.
data UpdateRuleVersionResponse = UpdateRuleVersionResponse'
  { -- | The new rule version that was created.
    UpdateRuleVersionResponse -> Maybe Rule
rule :: Prelude.Maybe Rule,
    -- | The response's http status code.
    UpdateRuleVersionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdateRuleVersionResponse -> UpdateRuleVersionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateRuleVersionResponse -> UpdateRuleVersionResponse -> Bool
$c/= :: UpdateRuleVersionResponse -> UpdateRuleVersionResponse -> Bool
== :: UpdateRuleVersionResponse -> UpdateRuleVersionResponse -> Bool
$c== :: UpdateRuleVersionResponse -> UpdateRuleVersionResponse -> Bool
Prelude.Eq, ReadPrec [UpdateRuleVersionResponse]
ReadPrec UpdateRuleVersionResponse
Int -> ReadS UpdateRuleVersionResponse
ReadS [UpdateRuleVersionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateRuleVersionResponse]
$creadListPrec :: ReadPrec [UpdateRuleVersionResponse]
readPrec :: ReadPrec UpdateRuleVersionResponse
$creadPrec :: ReadPrec UpdateRuleVersionResponse
readList :: ReadS [UpdateRuleVersionResponse]
$creadList :: ReadS [UpdateRuleVersionResponse]
readsPrec :: Int -> ReadS UpdateRuleVersionResponse
$creadsPrec :: Int -> ReadS UpdateRuleVersionResponse
Prelude.Read, Int -> UpdateRuleVersionResponse -> ShowS
[UpdateRuleVersionResponse] -> ShowS
UpdateRuleVersionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateRuleVersionResponse] -> ShowS
$cshowList :: [UpdateRuleVersionResponse] -> ShowS
show :: UpdateRuleVersionResponse -> String
$cshow :: UpdateRuleVersionResponse -> String
showsPrec :: Int -> UpdateRuleVersionResponse -> ShowS
$cshowsPrec :: Int -> UpdateRuleVersionResponse -> ShowS
Prelude.Show, forall x.
Rep UpdateRuleVersionResponse x -> UpdateRuleVersionResponse
forall x.
UpdateRuleVersionResponse -> Rep UpdateRuleVersionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdateRuleVersionResponse x -> UpdateRuleVersionResponse
$cfrom :: forall x.
UpdateRuleVersionResponse -> Rep UpdateRuleVersionResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdateRuleVersionResponse' 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:
--
-- 'rule', 'updateRuleVersionResponse_rule' - The new rule version that was created.
--
-- 'httpStatus', 'updateRuleVersionResponse_httpStatus' - The response's http status code.
newUpdateRuleVersionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateRuleVersionResponse
newUpdateRuleVersionResponse :: Int -> UpdateRuleVersionResponse
newUpdateRuleVersionResponse Int
pHttpStatus_ =
  UpdateRuleVersionResponse'
    { $sel:rule:UpdateRuleVersionResponse' :: Maybe Rule
rule = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateRuleVersionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The new rule version that was created.
updateRuleVersionResponse_rule :: Lens.Lens' UpdateRuleVersionResponse (Prelude.Maybe Rule)
updateRuleVersionResponse_rule :: Lens' UpdateRuleVersionResponse (Maybe Rule)
updateRuleVersionResponse_rule = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateRuleVersionResponse' {Maybe Rule
rule :: Maybe Rule
$sel:rule:UpdateRuleVersionResponse' :: UpdateRuleVersionResponse -> Maybe Rule
rule} -> Maybe Rule
rule) (\s :: UpdateRuleVersionResponse
s@UpdateRuleVersionResponse' {} Maybe Rule
a -> UpdateRuleVersionResponse
s {$sel:rule:UpdateRuleVersionResponse' :: Maybe Rule
rule = Maybe Rule
a} :: UpdateRuleVersionResponse)

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

instance Prelude.NFData UpdateRuleVersionResponse where
  rnf :: UpdateRuleVersionResponse -> ()
rnf UpdateRuleVersionResponse' {Int
Maybe Rule
httpStatus :: Int
rule :: Maybe Rule
$sel:httpStatus:UpdateRuleVersionResponse' :: UpdateRuleVersionResponse -> Int
$sel:rule:UpdateRuleVersionResponse' :: UpdateRuleVersionResponse -> Maybe Rule
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Rule
rule
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus