{-# 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.Route53Resolver.UpdateResolverRule
-- 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 settings for a specified Resolver rule. @ResolverRuleId@ is
-- required, and all other parameters are optional. If you don\'t specify a
-- parameter, it retains its current value.
module Amazonka.Route53Resolver.UpdateResolverRule
  ( -- * Creating a Request
    UpdateResolverRule (..),
    newUpdateResolverRule,

    -- * Request Lenses
    updateResolverRule_resolverRuleId,
    updateResolverRule_config,

    -- * Destructuring the Response
    UpdateResolverRuleResponse (..),
    newUpdateResolverRuleResponse,

    -- * Response Lenses
    updateResolverRuleResponse_resolverRule,
    updateResolverRuleResponse_httpStatus,
  )
where

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

-- | /See:/ 'newUpdateResolverRule' smart constructor.
data UpdateResolverRule = UpdateResolverRule'
  { -- | The ID of the Resolver rule that you want to update.
    UpdateResolverRule -> Text
resolverRuleId :: Prelude.Text,
    -- | The new settings for the Resolver rule.
    UpdateResolverRule -> ResolverRuleConfig
config :: ResolverRuleConfig
  }
  deriving (UpdateResolverRule -> UpdateResolverRule -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateResolverRule -> UpdateResolverRule -> Bool
$c/= :: UpdateResolverRule -> UpdateResolverRule -> Bool
== :: UpdateResolverRule -> UpdateResolverRule -> Bool
$c== :: UpdateResolverRule -> UpdateResolverRule -> Bool
Prelude.Eq, ReadPrec [UpdateResolverRule]
ReadPrec UpdateResolverRule
Int -> ReadS UpdateResolverRule
ReadS [UpdateResolverRule]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateResolverRule]
$creadListPrec :: ReadPrec [UpdateResolverRule]
readPrec :: ReadPrec UpdateResolverRule
$creadPrec :: ReadPrec UpdateResolverRule
readList :: ReadS [UpdateResolverRule]
$creadList :: ReadS [UpdateResolverRule]
readsPrec :: Int -> ReadS UpdateResolverRule
$creadsPrec :: Int -> ReadS UpdateResolverRule
Prelude.Read, Int -> UpdateResolverRule -> ShowS
[UpdateResolverRule] -> ShowS
UpdateResolverRule -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateResolverRule] -> ShowS
$cshowList :: [UpdateResolverRule] -> ShowS
show :: UpdateResolverRule -> String
$cshow :: UpdateResolverRule -> String
showsPrec :: Int -> UpdateResolverRule -> ShowS
$cshowsPrec :: Int -> UpdateResolverRule -> ShowS
Prelude.Show, forall x. Rep UpdateResolverRule x -> UpdateResolverRule
forall x. UpdateResolverRule -> Rep UpdateResolverRule x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateResolverRule x -> UpdateResolverRule
$cfrom :: forall x. UpdateResolverRule -> Rep UpdateResolverRule x
Prelude.Generic)

-- |
-- Create a value of 'UpdateResolverRule' 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:
--
-- 'resolverRuleId', 'updateResolverRule_resolverRuleId' - The ID of the Resolver rule that you want to update.
--
-- 'config', 'updateResolverRule_config' - The new settings for the Resolver rule.
newUpdateResolverRule ::
  -- | 'resolverRuleId'
  Prelude.Text ->
  -- | 'config'
  ResolverRuleConfig ->
  UpdateResolverRule
newUpdateResolverRule :: Text -> ResolverRuleConfig -> UpdateResolverRule
newUpdateResolverRule Text
pResolverRuleId_ ResolverRuleConfig
pConfig_ =
  UpdateResolverRule'
    { $sel:resolverRuleId:UpdateResolverRule' :: Text
resolverRuleId =
        Text
pResolverRuleId_,
      $sel:config:UpdateResolverRule' :: ResolverRuleConfig
config = ResolverRuleConfig
pConfig_
    }

-- | The ID of the Resolver rule that you want to update.
updateResolverRule_resolverRuleId :: Lens.Lens' UpdateResolverRule Prelude.Text
updateResolverRule_resolverRuleId :: Lens' UpdateResolverRule Text
updateResolverRule_resolverRuleId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolverRule' {Text
resolverRuleId :: Text
$sel:resolverRuleId:UpdateResolverRule' :: UpdateResolverRule -> Text
resolverRuleId} -> Text
resolverRuleId) (\s :: UpdateResolverRule
s@UpdateResolverRule' {} Text
a -> UpdateResolverRule
s {$sel:resolverRuleId:UpdateResolverRule' :: Text
resolverRuleId = Text
a} :: UpdateResolverRule)

-- | The new settings for the Resolver rule.
updateResolverRule_config :: Lens.Lens' UpdateResolverRule ResolverRuleConfig
updateResolverRule_config :: Lens' UpdateResolverRule ResolverRuleConfig
updateResolverRule_config = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolverRule' {ResolverRuleConfig
config :: ResolverRuleConfig
$sel:config:UpdateResolverRule' :: UpdateResolverRule -> ResolverRuleConfig
config} -> ResolverRuleConfig
config) (\s :: UpdateResolverRule
s@UpdateResolverRule' {} ResolverRuleConfig
a -> UpdateResolverRule
s {$sel:config:UpdateResolverRule' :: ResolverRuleConfig
config = ResolverRuleConfig
a} :: UpdateResolverRule)

instance Core.AWSRequest UpdateResolverRule where
  type
    AWSResponse UpdateResolverRule =
      UpdateResolverRuleResponse
  request :: (Service -> Service)
-> UpdateResolverRule -> Request UpdateResolverRule
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 UpdateResolverRule
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdateResolverRule)))
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 ResolverRule -> Int -> UpdateResolverRuleResponse
UpdateResolverRuleResponse'
            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
"ResolverRule")
            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 UpdateResolverRule where
  hashWithSalt :: Int -> UpdateResolverRule -> Int
hashWithSalt Int
_salt UpdateResolverRule' {Text
ResolverRuleConfig
config :: ResolverRuleConfig
resolverRuleId :: Text
$sel:config:UpdateResolverRule' :: UpdateResolverRule -> ResolverRuleConfig
$sel:resolverRuleId:UpdateResolverRule' :: UpdateResolverRule -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
resolverRuleId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ResolverRuleConfig
config

instance Prelude.NFData UpdateResolverRule where
  rnf :: UpdateResolverRule -> ()
rnf UpdateResolverRule' {Text
ResolverRuleConfig
config :: ResolverRuleConfig
resolverRuleId :: Text
$sel:config:UpdateResolverRule' :: UpdateResolverRule -> ResolverRuleConfig
$sel:resolverRuleId:UpdateResolverRule' :: UpdateResolverRule -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
resolverRuleId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ResolverRuleConfig
config

instance Data.ToHeaders UpdateResolverRule where
  toHeaders :: UpdateResolverRule -> 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
"Route53Resolver.UpdateResolverRule" ::
                          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 UpdateResolverRule where
  toJSON :: UpdateResolverRule -> Value
toJSON UpdateResolverRule' {Text
ResolverRuleConfig
config :: ResolverRuleConfig
resolverRuleId :: Text
$sel:config:UpdateResolverRule' :: UpdateResolverRule -> ResolverRuleConfig
$sel:resolverRuleId:UpdateResolverRule' :: UpdateResolverRule -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just
              (Key
"ResolverRuleId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
resolverRuleId),
            forall a. a -> Maybe a
Prelude.Just (Key
"Config" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ResolverRuleConfig
config)
          ]
      )

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

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

-- | /See:/ 'newUpdateResolverRuleResponse' smart constructor.
data UpdateResolverRuleResponse = UpdateResolverRuleResponse'
  { -- | The response to an @UpdateResolverRule@ request.
    UpdateResolverRuleResponse -> Maybe ResolverRule
resolverRule :: Prelude.Maybe ResolverRule,
    -- | The response's http status code.
    UpdateResolverRuleResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdateResolverRuleResponse -> UpdateResolverRuleResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateResolverRuleResponse -> UpdateResolverRuleResponse -> Bool
$c/= :: UpdateResolverRuleResponse -> UpdateResolverRuleResponse -> Bool
== :: UpdateResolverRuleResponse -> UpdateResolverRuleResponse -> Bool
$c== :: UpdateResolverRuleResponse -> UpdateResolverRuleResponse -> Bool
Prelude.Eq, ReadPrec [UpdateResolverRuleResponse]
ReadPrec UpdateResolverRuleResponse
Int -> ReadS UpdateResolverRuleResponse
ReadS [UpdateResolverRuleResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateResolverRuleResponse]
$creadListPrec :: ReadPrec [UpdateResolverRuleResponse]
readPrec :: ReadPrec UpdateResolverRuleResponse
$creadPrec :: ReadPrec UpdateResolverRuleResponse
readList :: ReadS [UpdateResolverRuleResponse]
$creadList :: ReadS [UpdateResolverRuleResponse]
readsPrec :: Int -> ReadS UpdateResolverRuleResponse
$creadsPrec :: Int -> ReadS UpdateResolverRuleResponse
Prelude.Read, Int -> UpdateResolverRuleResponse -> ShowS
[UpdateResolverRuleResponse] -> ShowS
UpdateResolverRuleResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateResolverRuleResponse] -> ShowS
$cshowList :: [UpdateResolverRuleResponse] -> ShowS
show :: UpdateResolverRuleResponse -> String
$cshow :: UpdateResolverRuleResponse -> String
showsPrec :: Int -> UpdateResolverRuleResponse -> ShowS
$cshowsPrec :: Int -> UpdateResolverRuleResponse -> ShowS
Prelude.Show, forall x.
Rep UpdateResolverRuleResponse x -> UpdateResolverRuleResponse
forall x.
UpdateResolverRuleResponse -> Rep UpdateResolverRuleResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdateResolverRuleResponse x -> UpdateResolverRuleResponse
$cfrom :: forall x.
UpdateResolverRuleResponse -> Rep UpdateResolverRuleResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdateResolverRuleResponse' 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:
--
-- 'resolverRule', 'updateResolverRuleResponse_resolverRule' - The response to an @UpdateResolverRule@ request.
--
-- 'httpStatus', 'updateResolverRuleResponse_httpStatus' - The response's http status code.
newUpdateResolverRuleResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateResolverRuleResponse
newUpdateResolverRuleResponse :: Int -> UpdateResolverRuleResponse
newUpdateResolverRuleResponse Int
pHttpStatus_ =
  UpdateResolverRuleResponse'
    { $sel:resolverRule:UpdateResolverRuleResponse' :: Maybe ResolverRule
resolverRule =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateResolverRuleResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The response to an @UpdateResolverRule@ request.
updateResolverRuleResponse_resolverRule :: Lens.Lens' UpdateResolverRuleResponse (Prelude.Maybe ResolverRule)
updateResolverRuleResponse_resolverRule :: Lens' UpdateResolverRuleResponse (Maybe ResolverRule)
updateResolverRuleResponse_resolverRule = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolverRuleResponse' {Maybe ResolverRule
resolverRule :: Maybe ResolverRule
$sel:resolverRule:UpdateResolverRuleResponse' :: UpdateResolverRuleResponse -> Maybe ResolverRule
resolverRule} -> Maybe ResolverRule
resolverRule) (\s :: UpdateResolverRuleResponse
s@UpdateResolverRuleResponse' {} Maybe ResolverRule
a -> UpdateResolverRuleResponse
s {$sel:resolverRule:UpdateResolverRuleResponse' :: Maybe ResolverRule
resolverRule = Maybe ResolverRule
a} :: UpdateResolverRuleResponse)

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

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