{-# 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.UpdateResolverDnssecConfig
-- 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 an existing DNSSEC validation configuration. If there is no
-- existing DNSSEC validation configuration, one is created.
module Amazonka.Route53Resolver.UpdateResolverDnssecConfig
  ( -- * Creating a Request
    UpdateResolverDnssecConfig (..),
    newUpdateResolverDnssecConfig,

    -- * Request Lenses
    updateResolverDnssecConfig_resourceId,
    updateResolverDnssecConfig_validation,

    -- * Destructuring the Response
    UpdateResolverDnssecConfigResponse (..),
    newUpdateResolverDnssecConfigResponse,

    -- * Response Lenses
    updateResolverDnssecConfigResponse_resolverDNSSECConfig,
    updateResolverDnssecConfigResponse_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:/ 'newUpdateResolverDnssecConfig' smart constructor.
data UpdateResolverDnssecConfig = UpdateResolverDnssecConfig'
  { -- | The ID of the virtual private cloud (VPC) that you\'re updating the
    -- DNSSEC validation status for.
    UpdateResolverDnssecConfig -> Text
resourceId :: Prelude.Text,
    -- | The new value that you are specifying for DNSSEC validation for the VPC.
    -- The value can be @ENABLE@ or @DISABLE@. Be aware that it can take time
    -- for a validation status change to be completed.
    UpdateResolverDnssecConfig -> Validation
validation :: Validation
  }
  deriving (UpdateResolverDnssecConfig -> UpdateResolverDnssecConfig -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateResolverDnssecConfig -> UpdateResolverDnssecConfig -> Bool
$c/= :: UpdateResolverDnssecConfig -> UpdateResolverDnssecConfig -> Bool
== :: UpdateResolverDnssecConfig -> UpdateResolverDnssecConfig -> Bool
$c== :: UpdateResolverDnssecConfig -> UpdateResolverDnssecConfig -> Bool
Prelude.Eq, ReadPrec [UpdateResolverDnssecConfig]
ReadPrec UpdateResolverDnssecConfig
Int -> ReadS UpdateResolverDnssecConfig
ReadS [UpdateResolverDnssecConfig]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateResolverDnssecConfig]
$creadListPrec :: ReadPrec [UpdateResolverDnssecConfig]
readPrec :: ReadPrec UpdateResolverDnssecConfig
$creadPrec :: ReadPrec UpdateResolverDnssecConfig
readList :: ReadS [UpdateResolverDnssecConfig]
$creadList :: ReadS [UpdateResolverDnssecConfig]
readsPrec :: Int -> ReadS UpdateResolverDnssecConfig
$creadsPrec :: Int -> ReadS UpdateResolverDnssecConfig
Prelude.Read, Int -> UpdateResolverDnssecConfig -> ShowS
[UpdateResolverDnssecConfig] -> ShowS
UpdateResolverDnssecConfig -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateResolverDnssecConfig] -> ShowS
$cshowList :: [UpdateResolverDnssecConfig] -> ShowS
show :: UpdateResolverDnssecConfig -> String
$cshow :: UpdateResolverDnssecConfig -> String
showsPrec :: Int -> UpdateResolverDnssecConfig -> ShowS
$cshowsPrec :: Int -> UpdateResolverDnssecConfig -> ShowS
Prelude.Show, forall x.
Rep UpdateResolverDnssecConfig x -> UpdateResolverDnssecConfig
forall x.
UpdateResolverDnssecConfig -> Rep UpdateResolverDnssecConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdateResolverDnssecConfig x -> UpdateResolverDnssecConfig
$cfrom :: forall x.
UpdateResolverDnssecConfig -> Rep UpdateResolverDnssecConfig x
Prelude.Generic)

-- |
-- Create a value of 'UpdateResolverDnssecConfig' 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:
--
-- 'resourceId', 'updateResolverDnssecConfig_resourceId' - The ID of the virtual private cloud (VPC) that you\'re updating the
-- DNSSEC validation status for.
--
-- 'validation', 'updateResolverDnssecConfig_validation' - The new value that you are specifying for DNSSEC validation for the VPC.
-- The value can be @ENABLE@ or @DISABLE@. Be aware that it can take time
-- for a validation status change to be completed.
newUpdateResolverDnssecConfig ::
  -- | 'resourceId'
  Prelude.Text ->
  -- | 'validation'
  Validation ->
  UpdateResolverDnssecConfig
newUpdateResolverDnssecConfig :: Text -> Validation -> UpdateResolverDnssecConfig
newUpdateResolverDnssecConfig
  Text
pResourceId_
  Validation
pValidation_ =
    UpdateResolverDnssecConfig'
      { $sel:resourceId:UpdateResolverDnssecConfig' :: Text
resourceId =
          Text
pResourceId_,
        $sel:validation:UpdateResolverDnssecConfig' :: Validation
validation = Validation
pValidation_
      }

-- | The ID of the virtual private cloud (VPC) that you\'re updating the
-- DNSSEC validation status for.
updateResolverDnssecConfig_resourceId :: Lens.Lens' UpdateResolverDnssecConfig Prelude.Text
updateResolverDnssecConfig_resourceId :: Lens' UpdateResolverDnssecConfig Text
updateResolverDnssecConfig_resourceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolverDnssecConfig' {Text
resourceId :: Text
$sel:resourceId:UpdateResolverDnssecConfig' :: UpdateResolverDnssecConfig -> Text
resourceId} -> Text
resourceId) (\s :: UpdateResolverDnssecConfig
s@UpdateResolverDnssecConfig' {} Text
a -> UpdateResolverDnssecConfig
s {$sel:resourceId:UpdateResolverDnssecConfig' :: Text
resourceId = Text
a} :: UpdateResolverDnssecConfig)

-- | The new value that you are specifying for DNSSEC validation for the VPC.
-- The value can be @ENABLE@ or @DISABLE@. Be aware that it can take time
-- for a validation status change to be completed.
updateResolverDnssecConfig_validation :: Lens.Lens' UpdateResolverDnssecConfig Validation
updateResolverDnssecConfig_validation :: Lens' UpdateResolverDnssecConfig Validation
updateResolverDnssecConfig_validation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolverDnssecConfig' {Validation
validation :: Validation
$sel:validation:UpdateResolverDnssecConfig' :: UpdateResolverDnssecConfig -> Validation
validation} -> Validation
validation) (\s :: UpdateResolverDnssecConfig
s@UpdateResolverDnssecConfig' {} Validation
a -> UpdateResolverDnssecConfig
s {$sel:validation:UpdateResolverDnssecConfig' :: Validation
validation = Validation
a} :: UpdateResolverDnssecConfig)

instance Core.AWSRequest UpdateResolverDnssecConfig where
  type
    AWSResponse UpdateResolverDnssecConfig =
      UpdateResolverDnssecConfigResponse
  request :: (Service -> Service)
-> UpdateResolverDnssecConfig -> Request UpdateResolverDnssecConfig
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 UpdateResolverDnssecConfig
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdateResolverDnssecConfig)))
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 ResolverDnssecConfig
-> Int -> UpdateResolverDnssecConfigResponse
UpdateResolverDnssecConfigResponse'
            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
"ResolverDNSSECConfig")
            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 UpdateResolverDnssecConfig where
  hashWithSalt :: Int -> UpdateResolverDnssecConfig -> Int
hashWithSalt Int
_salt UpdateResolverDnssecConfig' {Text
Validation
validation :: Validation
resourceId :: Text
$sel:validation:UpdateResolverDnssecConfig' :: UpdateResolverDnssecConfig -> Validation
$sel:resourceId:UpdateResolverDnssecConfig' :: UpdateResolverDnssecConfig -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
resourceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Validation
validation

instance Prelude.NFData UpdateResolverDnssecConfig where
  rnf :: UpdateResolverDnssecConfig -> ()
rnf UpdateResolverDnssecConfig' {Text
Validation
validation :: Validation
resourceId :: Text
$sel:validation:UpdateResolverDnssecConfig' :: UpdateResolverDnssecConfig -> Validation
$sel:resourceId:UpdateResolverDnssecConfig' :: UpdateResolverDnssecConfig -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
resourceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Validation
validation

instance Data.ToHeaders UpdateResolverDnssecConfig where
  toHeaders :: UpdateResolverDnssecConfig -> 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.UpdateResolverDnssecConfig" ::
                          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 UpdateResolverDnssecConfig where
  toJSON :: UpdateResolverDnssecConfig -> Value
toJSON UpdateResolverDnssecConfig' {Text
Validation
validation :: Validation
resourceId :: Text
$sel:validation:UpdateResolverDnssecConfig' :: UpdateResolverDnssecConfig -> Validation
$sel:resourceId:UpdateResolverDnssecConfig' :: UpdateResolverDnssecConfig -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"ResourceId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
resourceId),
            forall a. a -> Maybe a
Prelude.Just (Key
"Validation" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Validation
validation)
          ]
      )

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

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

-- | /See:/ 'newUpdateResolverDnssecConfigResponse' smart constructor.
data UpdateResolverDnssecConfigResponse = UpdateResolverDnssecConfigResponse'
  { -- | A complex type that contains settings for the specified DNSSEC
    -- configuration.
    UpdateResolverDnssecConfigResponse -> Maybe ResolverDnssecConfig
resolverDNSSECConfig :: Prelude.Maybe ResolverDnssecConfig,
    -- | The response's http status code.
    UpdateResolverDnssecConfigResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdateResolverDnssecConfigResponse
-> UpdateResolverDnssecConfigResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateResolverDnssecConfigResponse
-> UpdateResolverDnssecConfigResponse -> Bool
$c/= :: UpdateResolverDnssecConfigResponse
-> UpdateResolverDnssecConfigResponse -> Bool
== :: UpdateResolverDnssecConfigResponse
-> UpdateResolverDnssecConfigResponse -> Bool
$c== :: UpdateResolverDnssecConfigResponse
-> UpdateResolverDnssecConfigResponse -> Bool
Prelude.Eq, ReadPrec [UpdateResolverDnssecConfigResponse]
ReadPrec UpdateResolverDnssecConfigResponse
Int -> ReadS UpdateResolverDnssecConfigResponse
ReadS [UpdateResolverDnssecConfigResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateResolverDnssecConfigResponse]
$creadListPrec :: ReadPrec [UpdateResolverDnssecConfigResponse]
readPrec :: ReadPrec UpdateResolverDnssecConfigResponse
$creadPrec :: ReadPrec UpdateResolverDnssecConfigResponse
readList :: ReadS [UpdateResolverDnssecConfigResponse]
$creadList :: ReadS [UpdateResolverDnssecConfigResponse]
readsPrec :: Int -> ReadS UpdateResolverDnssecConfigResponse
$creadsPrec :: Int -> ReadS UpdateResolverDnssecConfigResponse
Prelude.Read, Int -> UpdateResolverDnssecConfigResponse -> ShowS
[UpdateResolverDnssecConfigResponse] -> ShowS
UpdateResolverDnssecConfigResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateResolverDnssecConfigResponse] -> ShowS
$cshowList :: [UpdateResolverDnssecConfigResponse] -> ShowS
show :: UpdateResolverDnssecConfigResponse -> String
$cshow :: UpdateResolverDnssecConfigResponse -> String
showsPrec :: Int -> UpdateResolverDnssecConfigResponse -> ShowS
$cshowsPrec :: Int -> UpdateResolverDnssecConfigResponse -> ShowS
Prelude.Show, forall x.
Rep UpdateResolverDnssecConfigResponse x
-> UpdateResolverDnssecConfigResponse
forall x.
UpdateResolverDnssecConfigResponse
-> Rep UpdateResolverDnssecConfigResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdateResolverDnssecConfigResponse x
-> UpdateResolverDnssecConfigResponse
$cfrom :: forall x.
UpdateResolverDnssecConfigResponse
-> Rep UpdateResolverDnssecConfigResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdateResolverDnssecConfigResponse' 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:
--
-- 'resolverDNSSECConfig', 'updateResolverDnssecConfigResponse_resolverDNSSECConfig' - A complex type that contains settings for the specified DNSSEC
-- configuration.
--
-- 'httpStatus', 'updateResolverDnssecConfigResponse_httpStatus' - The response's http status code.
newUpdateResolverDnssecConfigResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateResolverDnssecConfigResponse
newUpdateResolverDnssecConfigResponse :: Int -> UpdateResolverDnssecConfigResponse
newUpdateResolverDnssecConfigResponse Int
pHttpStatus_ =
  UpdateResolverDnssecConfigResponse'
    { $sel:resolverDNSSECConfig:UpdateResolverDnssecConfigResponse' :: Maybe ResolverDnssecConfig
resolverDNSSECConfig =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateResolverDnssecConfigResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A complex type that contains settings for the specified DNSSEC
-- configuration.
updateResolverDnssecConfigResponse_resolverDNSSECConfig :: Lens.Lens' UpdateResolverDnssecConfigResponse (Prelude.Maybe ResolverDnssecConfig)
updateResolverDnssecConfigResponse_resolverDNSSECConfig :: Lens'
  UpdateResolverDnssecConfigResponse (Maybe ResolverDnssecConfig)
updateResolverDnssecConfigResponse_resolverDNSSECConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolverDnssecConfigResponse' {Maybe ResolverDnssecConfig
resolverDNSSECConfig :: Maybe ResolverDnssecConfig
$sel:resolverDNSSECConfig:UpdateResolverDnssecConfigResponse' :: UpdateResolverDnssecConfigResponse -> Maybe ResolverDnssecConfig
resolverDNSSECConfig} -> Maybe ResolverDnssecConfig
resolverDNSSECConfig) (\s :: UpdateResolverDnssecConfigResponse
s@UpdateResolverDnssecConfigResponse' {} Maybe ResolverDnssecConfig
a -> UpdateResolverDnssecConfigResponse
s {$sel:resolverDNSSECConfig:UpdateResolverDnssecConfigResponse' :: Maybe ResolverDnssecConfig
resolverDNSSECConfig = Maybe ResolverDnssecConfig
a} :: UpdateResolverDnssecConfigResponse)

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

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