{-# 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.GetResolverEndpoint
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Gets information about a specified Resolver endpoint, such as whether
-- it\'s an inbound or an outbound Resolver endpoint, and the current
-- status of the endpoint.
module Amazonka.Route53Resolver.GetResolverEndpoint
  ( -- * Creating a Request
    GetResolverEndpoint (..),
    newGetResolverEndpoint,

    -- * Request Lenses
    getResolverEndpoint_resolverEndpointId,

    -- * Destructuring the Response
    GetResolverEndpointResponse (..),
    newGetResolverEndpointResponse,

    -- * Response Lenses
    getResolverEndpointResponse_resolverEndpoint,
    getResolverEndpointResponse_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:/ 'newGetResolverEndpoint' smart constructor.
data GetResolverEndpoint = GetResolverEndpoint'
  { -- | The ID of the Resolver endpoint that you want to get information about.
    GetResolverEndpoint -> Text
resolverEndpointId :: Prelude.Text
  }
  deriving (GetResolverEndpoint -> GetResolverEndpoint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetResolverEndpoint -> GetResolverEndpoint -> Bool
$c/= :: GetResolverEndpoint -> GetResolverEndpoint -> Bool
== :: GetResolverEndpoint -> GetResolverEndpoint -> Bool
$c== :: GetResolverEndpoint -> GetResolverEndpoint -> Bool
Prelude.Eq, ReadPrec [GetResolverEndpoint]
ReadPrec GetResolverEndpoint
Int -> ReadS GetResolverEndpoint
ReadS [GetResolverEndpoint]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetResolverEndpoint]
$creadListPrec :: ReadPrec [GetResolverEndpoint]
readPrec :: ReadPrec GetResolverEndpoint
$creadPrec :: ReadPrec GetResolverEndpoint
readList :: ReadS [GetResolverEndpoint]
$creadList :: ReadS [GetResolverEndpoint]
readsPrec :: Int -> ReadS GetResolverEndpoint
$creadsPrec :: Int -> ReadS GetResolverEndpoint
Prelude.Read, Int -> GetResolverEndpoint -> ShowS
[GetResolverEndpoint] -> ShowS
GetResolverEndpoint -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetResolverEndpoint] -> ShowS
$cshowList :: [GetResolverEndpoint] -> ShowS
show :: GetResolverEndpoint -> String
$cshow :: GetResolverEndpoint -> String
showsPrec :: Int -> GetResolverEndpoint -> ShowS
$cshowsPrec :: Int -> GetResolverEndpoint -> ShowS
Prelude.Show, forall x. Rep GetResolverEndpoint x -> GetResolverEndpoint
forall x. GetResolverEndpoint -> Rep GetResolverEndpoint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetResolverEndpoint x -> GetResolverEndpoint
$cfrom :: forall x. GetResolverEndpoint -> Rep GetResolverEndpoint x
Prelude.Generic)

-- |
-- Create a value of 'GetResolverEndpoint' 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:
--
-- 'resolverEndpointId', 'getResolverEndpoint_resolverEndpointId' - The ID of the Resolver endpoint that you want to get information about.
newGetResolverEndpoint ::
  -- | 'resolverEndpointId'
  Prelude.Text ->
  GetResolverEndpoint
newGetResolverEndpoint :: Text -> GetResolverEndpoint
newGetResolverEndpoint Text
pResolverEndpointId_ =
  GetResolverEndpoint'
    { $sel:resolverEndpointId:GetResolverEndpoint' :: Text
resolverEndpointId =
        Text
pResolverEndpointId_
    }

-- | The ID of the Resolver endpoint that you want to get information about.
getResolverEndpoint_resolverEndpointId :: Lens.Lens' GetResolverEndpoint Prelude.Text
getResolverEndpoint_resolverEndpointId :: Lens' GetResolverEndpoint Text
getResolverEndpoint_resolverEndpointId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetResolverEndpoint' {Text
resolverEndpointId :: Text
$sel:resolverEndpointId:GetResolverEndpoint' :: GetResolverEndpoint -> Text
resolverEndpointId} -> Text
resolverEndpointId) (\s :: GetResolverEndpoint
s@GetResolverEndpoint' {} Text
a -> GetResolverEndpoint
s {$sel:resolverEndpointId:GetResolverEndpoint' :: Text
resolverEndpointId = Text
a} :: GetResolverEndpoint)

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

instance Prelude.NFData GetResolverEndpoint where
  rnf :: GetResolverEndpoint -> ()
rnf GetResolverEndpoint' {Text
resolverEndpointId :: Text
$sel:resolverEndpointId:GetResolverEndpoint' :: GetResolverEndpoint -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
resolverEndpointId

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

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

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

-- | /See:/ 'newGetResolverEndpointResponse' smart constructor.
data GetResolverEndpointResponse = GetResolverEndpointResponse'
  { -- | Information about the Resolver endpoint that you specified in a
    -- @GetResolverEndpoint@ request.
    GetResolverEndpointResponse -> Maybe ResolverEndpoint
resolverEndpoint :: Prelude.Maybe ResolverEndpoint,
    -- | The response's http status code.
    GetResolverEndpointResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetResolverEndpointResponse -> GetResolverEndpointResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetResolverEndpointResponse -> GetResolverEndpointResponse -> Bool
$c/= :: GetResolverEndpointResponse -> GetResolverEndpointResponse -> Bool
== :: GetResolverEndpointResponse -> GetResolverEndpointResponse -> Bool
$c== :: GetResolverEndpointResponse -> GetResolverEndpointResponse -> Bool
Prelude.Eq, ReadPrec [GetResolverEndpointResponse]
ReadPrec GetResolverEndpointResponse
Int -> ReadS GetResolverEndpointResponse
ReadS [GetResolverEndpointResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetResolverEndpointResponse]
$creadListPrec :: ReadPrec [GetResolverEndpointResponse]
readPrec :: ReadPrec GetResolverEndpointResponse
$creadPrec :: ReadPrec GetResolverEndpointResponse
readList :: ReadS [GetResolverEndpointResponse]
$creadList :: ReadS [GetResolverEndpointResponse]
readsPrec :: Int -> ReadS GetResolverEndpointResponse
$creadsPrec :: Int -> ReadS GetResolverEndpointResponse
Prelude.Read, Int -> GetResolverEndpointResponse -> ShowS
[GetResolverEndpointResponse] -> ShowS
GetResolverEndpointResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetResolverEndpointResponse] -> ShowS
$cshowList :: [GetResolverEndpointResponse] -> ShowS
show :: GetResolverEndpointResponse -> String
$cshow :: GetResolverEndpointResponse -> String
showsPrec :: Int -> GetResolverEndpointResponse -> ShowS
$cshowsPrec :: Int -> GetResolverEndpointResponse -> ShowS
Prelude.Show, forall x.
Rep GetResolverEndpointResponse x -> GetResolverEndpointResponse
forall x.
GetResolverEndpointResponse -> Rep GetResolverEndpointResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetResolverEndpointResponse x -> GetResolverEndpointResponse
$cfrom :: forall x.
GetResolverEndpointResponse -> Rep GetResolverEndpointResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetResolverEndpointResponse' 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:
--
-- 'resolverEndpoint', 'getResolverEndpointResponse_resolverEndpoint' - Information about the Resolver endpoint that you specified in a
-- @GetResolverEndpoint@ request.
--
-- 'httpStatus', 'getResolverEndpointResponse_httpStatus' - The response's http status code.
newGetResolverEndpointResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetResolverEndpointResponse
newGetResolverEndpointResponse :: Int -> GetResolverEndpointResponse
newGetResolverEndpointResponse Int
pHttpStatus_ =
  GetResolverEndpointResponse'
    { $sel:resolverEndpoint:GetResolverEndpointResponse' :: Maybe ResolverEndpoint
resolverEndpoint =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetResolverEndpointResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the Resolver endpoint that you specified in a
-- @GetResolverEndpoint@ request.
getResolverEndpointResponse_resolverEndpoint :: Lens.Lens' GetResolverEndpointResponse (Prelude.Maybe ResolverEndpoint)
getResolverEndpointResponse_resolverEndpoint :: Lens' GetResolverEndpointResponse (Maybe ResolverEndpoint)
getResolverEndpointResponse_resolverEndpoint = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetResolverEndpointResponse' {Maybe ResolverEndpoint
resolverEndpoint :: Maybe ResolverEndpoint
$sel:resolverEndpoint:GetResolverEndpointResponse' :: GetResolverEndpointResponse -> Maybe ResolverEndpoint
resolverEndpoint} -> Maybe ResolverEndpoint
resolverEndpoint) (\s :: GetResolverEndpointResponse
s@GetResolverEndpointResponse' {} Maybe ResolverEndpoint
a -> GetResolverEndpointResponse
s {$sel:resolverEndpoint:GetResolverEndpointResponse' :: Maybe ResolverEndpoint
resolverEndpoint = Maybe ResolverEndpoint
a} :: GetResolverEndpointResponse)

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

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