{-# 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.Route53AutoNaming.UpdatePublicDnsNamespace
-- 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 public DNS namespace.
module Amazonka.Route53AutoNaming.UpdatePublicDnsNamespace
  ( -- * Creating a Request
    UpdatePublicDnsNamespace (..),
    newUpdatePublicDnsNamespace,

    -- * Request Lenses
    updatePublicDnsNamespace_updaterRequestId,
    updatePublicDnsNamespace_id,
    updatePublicDnsNamespace_namespace,

    -- * Destructuring the Response
    UpdatePublicDnsNamespaceResponse (..),
    newUpdatePublicDnsNamespaceResponse,

    -- * Response Lenses
    updatePublicDnsNamespaceResponse_operationId,
    updatePublicDnsNamespaceResponse_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.Route53AutoNaming.Types

-- | /See:/ 'newUpdatePublicDnsNamespace' smart constructor.
data UpdatePublicDnsNamespace = UpdatePublicDnsNamespace'
  { -- | A unique string that identifies the request and that allows failed
    -- @UpdatePublicDnsNamespace@ requests to be retried without the risk of
    -- running the operation twice. @UpdaterRequestId@ can be any unique string
    -- (for example, a date\/timestamp).
    UpdatePublicDnsNamespace -> Maybe Text
updaterRequestId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the namespace being updated.
    UpdatePublicDnsNamespace -> Text
id :: Prelude.Text,
    -- | Updated properties for the public DNS namespace.
    UpdatePublicDnsNamespace -> PublicDnsNamespaceChange
namespace :: PublicDnsNamespaceChange
  }
  deriving (UpdatePublicDnsNamespace -> UpdatePublicDnsNamespace -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdatePublicDnsNamespace -> UpdatePublicDnsNamespace -> Bool
$c/= :: UpdatePublicDnsNamespace -> UpdatePublicDnsNamespace -> Bool
== :: UpdatePublicDnsNamespace -> UpdatePublicDnsNamespace -> Bool
$c== :: UpdatePublicDnsNamespace -> UpdatePublicDnsNamespace -> Bool
Prelude.Eq, ReadPrec [UpdatePublicDnsNamespace]
ReadPrec UpdatePublicDnsNamespace
Int -> ReadS UpdatePublicDnsNamespace
ReadS [UpdatePublicDnsNamespace]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdatePublicDnsNamespace]
$creadListPrec :: ReadPrec [UpdatePublicDnsNamespace]
readPrec :: ReadPrec UpdatePublicDnsNamespace
$creadPrec :: ReadPrec UpdatePublicDnsNamespace
readList :: ReadS [UpdatePublicDnsNamespace]
$creadList :: ReadS [UpdatePublicDnsNamespace]
readsPrec :: Int -> ReadS UpdatePublicDnsNamespace
$creadsPrec :: Int -> ReadS UpdatePublicDnsNamespace
Prelude.Read, Int -> UpdatePublicDnsNamespace -> ShowS
[UpdatePublicDnsNamespace] -> ShowS
UpdatePublicDnsNamespace -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdatePublicDnsNamespace] -> ShowS
$cshowList :: [UpdatePublicDnsNamespace] -> ShowS
show :: UpdatePublicDnsNamespace -> String
$cshow :: UpdatePublicDnsNamespace -> String
showsPrec :: Int -> UpdatePublicDnsNamespace -> ShowS
$cshowsPrec :: Int -> UpdatePublicDnsNamespace -> ShowS
Prelude.Show, forall x.
Rep UpdatePublicDnsNamespace x -> UpdatePublicDnsNamespace
forall x.
UpdatePublicDnsNamespace -> Rep UpdatePublicDnsNamespace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdatePublicDnsNamespace x -> UpdatePublicDnsNamespace
$cfrom :: forall x.
UpdatePublicDnsNamespace -> Rep UpdatePublicDnsNamespace x
Prelude.Generic)

-- |
-- Create a value of 'UpdatePublicDnsNamespace' 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:
--
-- 'updaterRequestId', 'updatePublicDnsNamespace_updaterRequestId' - A unique string that identifies the request and that allows failed
-- @UpdatePublicDnsNamespace@ requests to be retried without the risk of
-- running the operation twice. @UpdaterRequestId@ can be any unique string
-- (for example, a date\/timestamp).
--
-- 'id', 'updatePublicDnsNamespace_id' - The ID of the namespace being updated.
--
-- 'namespace', 'updatePublicDnsNamespace_namespace' - Updated properties for the public DNS namespace.
newUpdatePublicDnsNamespace ::
  -- | 'id'
  Prelude.Text ->
  -- | 'namespace'
  PublicDnsNamespaceChange ->
  UpdatePublicDnsNamespace
newUpdatePublicDnsNamespace :: Text -> PublicDnsNamespaceChange -> UpdatePublicDnsNamespace
newUpdatePublicDnsNamespace Text
pId_ PublicDnsNamespaceChange
pNamespace_ =
  UpdatePublicDnsNamespace'
    { $sel:updaterRequestId:UpdatePublicDnsNamespace' :: Maybe Text
updaterRequestId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:id:UpdatePublicDnsNamespace' :: Text
id = Text
pId_,
      $sel:namespace:UpdatePublicDnsNamespace' :: PublicDnsNamespaceChange
namespace = PublicDnsNamespaceChange
pNamespace_
    }

-- | A unique string that identifies the request and that allows failed
-- @UpdatePublicDnsNamespace@ requests to be retried without the risk of
-- running the operation twice. @UpdaterRequestId@ can be any unique string
-- (for example, a date\/timestamp).
updatePublicDnsNamespace_updaterRequestId :: Lens.Lens' UpdatePublicDnsNamespace (Prelude.Maybe Prelude.Text)
updatePublicDnsNamespace_updaterRequestId :: Lens' UpdatePublicDnsNamespace (Maybe Text)
updatePublicDnsNamespace_updaterRequestId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePublicDnsNamespace' {Maybe Text
updaterRequestId :: Maybe Text
$sel:updaterRequestId:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> Maybe Text
updaterRequestId} -> Maybe Text
updaterRequestId) (\s :: UpdatePublicDnsNamespace
s@UpdatePublicDnsNamespace' {} Maybe Text
a -> UpdatePublicDnsNamespace
s {$sel:updaterRequestId:UpdatePublicDnsNamespace' :: Maybe Text
updaterRequestId = Maybe Text
a} :: UpdatePublicDnsNamespace)

-- | The ID of the namespace being updated.
updatePublicDnsNamespace_id :: Lens.Lens' UpdatePublicDnsNamespace Prelude.Text
updatePublicDnsNamespace_id :: Lens' UpdatePublicDnsNamespace Text
updatePublicDnsNamespace_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePublicDnsNamespace' {Text
id :: Text
$sel:id:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> Text
id} -> Text
id) (\s :: UpdatePublicDnsNamespace
s@UpdatePublicDnsNamespace' {} Text
a -> UpdatePublicDnsNamespace
s {$sel:id:UpdatePublicDnsNamespace' :: Text
id = Text
a} :: UpdatePublicDnsNamespace)

-- | Updated properties for the public DNS namespace.
updatePublicDnsNamespace_namespace :: Lens.Lens' UpdatePublicDnsNamespace PublicDnsNamespaceChange
updatePublicDnsNamespace_namespace :: Lens' UpdatePublicDnsNamespace PublicDnsNamespaceChange
updatePublicDnsNamespace_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePublicDnsNamespace' {PublicDnsNamespaceChange
namespace :: PublicDnsNamespaceChange
$sel:namespace:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> PublicDnsNamespaceChange
namespace} -> PublicDnsNamespaceChange
namespace) (\s :: UpdatePublicDnsNamespace
s@UpdatePublicDnsNamespace' {} PublicDnsNamespaceChange
a -> UpdatePublicDnsNamespace
s {$sel:namespace:UpdatePublicDnsNamespace' :: PublicDnsNamespaceChange
namespace = PublicDnsNamespaceChange
a} :: UpdatePublicDnsNamespace)

instance Core.AWSRequest UpdatePublicDnsNamespace where
  type
    AWSResponse UpdatePublicDnsNamespace =
      UpdatePublicDnsNamespaceResponse
  request :: (Service -> Service)
-> UpdatePublicDnsNamespace -> Request UpdatePublicDnsNamespace
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 UpdatePublicDnsNamespace
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdatePublicDnsNamespace)))
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 -> Int -> UpdatePublicDnsNamespaceResponse
UpdatePublicDnsNamespaceResponse'
            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
"OperationId")
            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 UpdatePublicDnsNamespace where
  hashWithSalt :: Int -> UpdatePublicDnsNamespace -> Int
hashWithSalt Int
_salt UpdatePublicDnsNamespace' {Maybe Text
Text
PublicDnsNamespaceChange
namespace :: PublicDnsNamespaceChange
id :: Text
updaterRequestId :: Maybe Text
$sel:namespace:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> PublicDnsNamespaceChange
$sel:id:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> Text
$sel:updaterRequestId:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
updaterRequestId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
id
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` PublicDnsNamespaceChange
namespace

instance Prelude.NFData UpdatePublicDnsNamespace where
  rnf :: UpdatePublicDnsNamespace -> ()
rnf UpdatePublicDnsNamespace' {Maybe Text
Text
PublicDnsNamespaceChange
namespace :: PublicDnsNamespaceChange
id :: Text
updaterRequestId :: Maybe Text
$sel:namespace:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> PublicDnsNamespaceChange
$sel:id:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> Text
$sel:updaterRequestId:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
updaterRequestId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf PublicDnsNamespaceChange
namespace

instance Data.ToHeaders UpdatePublicDnsNamespace where
  toHeaders :: UpdatePublicDnsNamespace -> 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
"Route53AutoNaming_v20170314.UpdatePublicDnsNamespace" ::
                          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 UpdatePublicDnsNamespace where
  toJSON :: UpdatePublicDnsNamespace -> Value
toJSON UpdatePublicDnsNamespace' {Maybe Text
Text
PublicDnsNamespaceChange
namespace :: PublicDnsNamespaceChange
id :: Text
updaterRequestId :: Maybe Text
$sel:namespace:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> PublicDnsNamespaceChange
$sel:id:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> Text
$sel:updaterRequestId:UpdatePublicDnsNamespace' :: UpdatePublicDnsNamespace -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"UpdaterRequestId" 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
updaterRequestId,
            forall a. a -> Maybe a
Prelude.Just (Key
"Id" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
id),
            forall a. a -> Maybe a
Prelude.Just (Key
"Namespace" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= PublicDnsNamespaceChange
namespace)
          ]
      )

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

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

-- | /See:/ 'newUpdatePublicDnsNamespaceResponse' smart constructor.
data UpdatePublicDnsNamespaceResponse = UpdatePublicDnsNamespaceResponse'
  { -- | A value that you can use to determine whether the request completed
    -- successfully. To get the status of the operation, see
    -- <https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html GetOperation>.
    UpdatePublicDnsNamespaceResponse -> Maybe Text
operationId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    UpdatePublicDnsNamespaceResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdatePublicDnsNamespaceResponse
-> UpdatePublicDnsNamespaceResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdatePublicDnsNamespaceResponse
-> UpdatePublicDnsNamespaceResponse -> Bool
$c/= :: UpdatePublicDnsNamespaceResponse
-> UpdatePublicDnsNamespaceResponse -> Bool
== :: UpdatePublicDnsNamespaceResponse
-> UpdatePublicDnsNamespaceResponse -> Bool
$c== :: UpdatePublicDnsNamespaceResponse
-> UpdatePublicDnsNamespaceResponse -> Bool
Prelude.Eq, ReadPrec [UpdatePublicDnsNamespaceResponse]
ReadPrec UpdatePublicDnsNamespaceResponse
Int -> ReadS UpdatePublicDnsNamespaceResponse
ReadS [UpdatePublicDnsNamespaceResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdatePublicDnsNamespaceResponse]
$creadListPrec :: ReadPrec [UpdatePublicDnsNamespaceResponse]
readPrec :: ReadPrec UpdatePublicDnsNamespaceResponse
$creadPrec :: ReadPrec UpdatePublicDnsNamespaceResponse
readList :: ReadS [UpdatePublicDnsNamespaceResponse]
$creadList :: ReadS [UpdatePublicDnsNamespaceResponse]
readsPrec :: Int -> ReadS UpdatePublicDnsNamespaceResponse
$creadsPrec :: Int -> ReadS UpdatePublicDnsNamespaceResponse
Prelude.Read, Int -> UpdatePublicDnsNamespaceResponse -> ShowS
[UpdatePublicDnsNamespaceResponse] -> ShowS
UpdatePublicDnsNamespaceResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdatePublicDnsNamespaceResponse] -> ShowS
$cshowList :: [UpdatePublicDnsNamespaceResponse] -> ShowS
show :: UpdatePublicDnsNamespaceResponse -> String
$cshow :: UpdatePublicDnsNamespaceResponse -> String
showsPrec :: Int -> UpdatePublicDnsNamespaceResponse -> ShowS
$cshowsPrec :: Int -> UpdatePublicDnsNamespaceResponse -> ShowS
Prelude.Show, forall x.
Rep UpdatePublicDnsNamespaceResponse x
-> UpdatePublicDnsNamespaceResponse
forall x.
UpdatePublicDnsNamespaceResponse
-> Rep UpdatePublicDnsNamespaceResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdatePublicDnsNamespaceResponse x
-> UpdatePublicDnsNamespaceResponse
$cfrom :: forall x.
UpdatePublicDnsNamespaceResponse
-> Rep UpdatePublicDnsNamespaceResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdatePublicDnsNamespaceResponse' 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:
--
-- 'operationId', 'updatePublicDnsNamespaceResponse_operationId' - A value that you can use to determine whether the request completed
-- successfully. To get the status of the operation, see
-- <https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html GetOperation>.
--
-- 'httpStatus', 'updatePublicDnsNamespaceResponse_httpStatus' - The response's http status code.
newUpdatePublicDnsNamespaceResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdatePublicDnsNamespaceResponse
newUpdatePublicDnsNamespaceResponse :: Int -> UpdatePublicDnsNamespaceResponse
newUpdatePublicDnsNamespaceResponse Int
pHttpStatus_ =
  UpdatePublicDnsNamespaceResponse'
    { $sel:operationId:UpdatePublicDnsNamespaceResponse' :: Maybe Text
operationId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdatePublicDnsNamespaceResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A value that you can use to determine whether the request completed
-- successfully. To get the status of the operation, see
-- <https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html GetOperation>.
updatePublicDnsNamespaceResponse_operationId :: Lens.Lens' UpdatePublicDnsNamespaceResponse (Prelude.Maybe Prelude.Text)
updatePublicDnsNamespaceResponse_operationId :: Lens' UpdatePublicDnsNamespaceResponse (Maybe Text)
updatePublicDnsNamespaceResponse_operationId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePublicDnsNamespaceResponse' {Maybe Text
operationId :: Maybe Text
$sel:operationId:UpdatePublicDnsNamespaceResponse' :: UpdatePublicDnsNamespaceResponse -> Maybe Text
operationId} -> Maybe Text
operationId) (\s :: UpdatePublicDnsNamespaceResponse
s@UpdatePublicDnsNamespaceResponse' {} Maybe Text
a -> UpdatePublicDnsNamespaceResponse
s {$sel:operationId:UpdatePublicDnsNamespaceResponse' :: Maybe Text
operationId = Maybe Text
a} :: UpdatePublicDnsNamespaceResponse)

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

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