{-# 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.NetworkManager.GetVpcAttachment
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns information about a VPC attachment.
module Amazonka.NetworkManager.GetVpcAttachment
  ( -- * Creating a Request
    GetVpcAttachment (..),
    newGetVpcAttachment,

    -- * Request Lenses
    getVpcAttachment_attachmentId,

    -- * Destructuring the Response
    GetVpcAttachmentResponse (..),
    newGetVpcAttachmentResponse,

    -- * Response Lenses
    getVpcAttachmentResponse_vpcAttachment,
    getVpcAttachmentResponse_httpStatus,
  )
where

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

-- | /See:/ 'newGetVpcAttachment' smart constructor.
data GetVpcAttachment = GetVpcAttachment'
  { -- | The ID of the attachment.
    GetVpcAttachment -> Text
attachmentId :: Prelude.Text
  }
  deriving (GetVpcAttachment -> GetVpcAttachment -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetVpcAttachment -> GetVpcAttachment -> Bool
$c/= :: GetVpcAttachment -> GetVpcAttachment -> Bool
== :: GetVpcAttachment -> GetVpcAttachment -> Bool
$c== :: GetVpcAttachment -> GetVpcAttachment -> Bool
Prelude.Eq, ReadPrec [GetVpcAttachment]
ReadPrec GetVpcAttachment
Int -> ReadS GetVpcAttachment
ReadS [GetVpcAttachment]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetVpcAttachment]
$creadListPrec :: ReadPrec [GetVpcAttachment]
readPrec :: ReadPrec GetVpcAttachment
$creadPrec :: ReadPrec GetVpcAttachment
readList :: ReadS [GetVpcAttachment]
$creadList :: ReadS [GetVpcAttachment]
readsPrec :: Int -> ReadS GetVpcAttachment
$creadsPrec :: Int -> ReadS GetVpcAttachment
Prelude.Read, Int -> GetVpcAttachment -> ShowS
[GetVpcAttachment] -> ShowS
GetVpcAttachment -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetVpcAttachment] -> ShowS
$cshowList :: [GetVpcAttachment] -> ShowS
show :: GetVpcAttachment -> String
$cshow :: GetVpcAttachment -> String
showsPrec :: Int -> GetVpcAttachment -> ShowS
$cshowsPrec :: Int -> GetVpcAttachment -> ShowS
Prelude.Show, forall x. Rep GetVpcAttachment x -> GetVpcAttachment
forall x. GetVpcAttachment -> Rep GetVpcAttachment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetVpcAttachment x -> GetVpcAttachment
$cfrom :: forall x. GetVpcAttachment -> Rep GetVpcAttachment x
Prelude.Generic)

-- |
-- Create a value of 'GetVpcAttachment' 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:
--
-- 'attachmentId', 'getVpcAttachment_attachmentId' - The ID of the attachment.
newGetVpcAttachment ::
  -- | 'attachmentId'
  Prelude.Text ->
  GetVpcAttachment
newGetVpcAttachment :: Text -> GetVpcAttachment
newGetVpcAttachment Text
pAttachmentId_ =
  GetVpcAttachment' {$sel:attachmentId:GetVpcAttachment' :: Text
attachmentId = Text
pAttachmentId_}

-- | The ID of the attachment.
getVpcAttachment_attachmentId :: Lens.Lens' GetVpcAttachment Prelude.Text
getVpcAttachment_attachmentId :: Lens' GetVpcAttachment Text
getVpcAttachment_attachmentId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetVpcAttachment' {Text
attachmentId :: Text
$sel:attachmentId:GetVpcAttachment' :: GetVpcAttachment -> Text
attachmentId} -> Text
attachmentId) (\s :: GetVpcAttachment
s@GetVpcAttachment' {} Text
a -> GetVpcAttachment
s {$sel:attachmentId:GetVpcAttachment' :: Text
attachmentId = Text
a} :: GetVpcAttachment)

instance Core.AWSRequest GetVpcAttachment where
  type
    AWSResponse GetVpcAttachment =
      GetVpcAttachmentResponse
  request :: (Service -> Service)
-> GetVpcAttachment -> Request GetVpcAttachment
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy GetVpcAttachment
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse GetVpcAttachment)))
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 VpcAttachment -> Int -> GetVpcAttachmentResponse
GetVpcAttachmentResponse'
            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
"VpcAttachment")
            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 GetVpcAttachment where
  hashWithSalt :: Int -> GetVpcAttachment -> Int
hashWithSalt Int
_salt GetVpcAttachment' {Text
attachmentId :: Text
$sel:attachmentId:GetVpcAttachment' :: GetVpcAttachment -> Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
attachmentId

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

instance Data.ToHeaders GetVpcAttachment where
  toHeaders :: GetVpcAttachment -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToPath GetVpcAttachment where
  toPath :: GetVpcAttachment -> ByteString
toPath GetVpcAttachment' {Text
attachmentId :: Text
$sel:attachmentId:GetVpcAttachment' :: GetVpcAttachment -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/vpc-attachments/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
attachmentId]

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

-- | /See:/ 'newGetVpcAttachmentResponse' smart constructor.
data GetVpcAttachmentResponse = GetVpcAttachmentResponse'
  { -- | Returns details about a VPC attachment.
    GetVpcAttachmentResponse -> Maybe VpcAttachment
vpcAttachment :: Prelude.Maybe VpcAttachment,
    -- | The response's http status code.
    GetVpcAttachmentResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetVpcAttachmentResponse -> GetVpcAttachmentResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetVpcAttachmentResponse -> GetVpcAttachmentResponse -> Bool
$c/= :: GetVpcAttachmentResponse -> GetVpcAttachmentResponse -> Bool
== :: GetVpcAttachmentResponse -> GetVpcAttachmentResponse -> Bool
$c== :: GetVpcAttachmentResponse -> GetVpcAttachmentResponse -> Bool
Prelude.Eq, ReadPrec [GetVpcAttachmentResponse]
ReadPrec GetVpcAttachmentResponse
Int -> ReadS GetVpcAttachmentResponse
ReadS [GetVpcAttachmentResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetVpcAttachmentResponse]
$creadListPrec :: ReadPrec [GetVpcAttachmentResponse]
readPrec :: ReadPrec GetVpcAttachmentResponse
$creadPrec :: ReadPrec GetVpcAttachmentResponse
readList :: ReadS [GetVpcAttachmentResponse]
$creadList :: ReadS [GetVpcAttachmentResponse]
readsPrec :: Int -> ReadS GetVpcAttachmentResponse
$creadsPrec :: Int -> ReadS GetVpcAttachmentResponse
Prelude.Read, Int -> GetVpcAttachmentResponse -> ShowS
[GetVpcAttachmentResponse] -> ShowS
GetVpcAttachmentResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetVpcAttachmentResponse] -> ShowS
$cshowList :: [GetVpcAttachmentResponse] -> ShowS
show :: GetVpcAttachmentResponse -> String
$cshow :: GetVpcAttachmentResponse -> String
showsPrec :: Int -> GetVpcAttachmentResponse -> ShowS
$cshowsPrec :: Int -> GetVpcAttachmentResponse -> ShowS
Prelude.Show, forall x.
Rep GetVpcAttachmentResponse x -> GetVpcAttachmentResponse
forall x.
GetVpcAttachmentResponse -> Rep GetVpcAttachmentResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetVpcAttachmentResponse x -> GetVpcAttachmentResponse
$cfrom :: forall x.
GetVpcAttachmentResponse -> Rep GetVpcAttachmentResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetVpcAttachmentResponse' 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:
--
-- 'vpcAttachment', 'getVpcAttachmentResponse_vpcAttachment' - Returns details about a VPC attachment.
--
-- 'httpStatus', 'getVpcAttachmentResponse_httpStatus' - The response's http status code.
newGetVpcAttachmentResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetVpcAttachmentResponse
newGetVpcAttachmentResponse :: Int -> GetVpcAttachmentResponse
newGetVpcAttachmentResponse Int
pHttpStatus_ =
  GetVpcAttachmentResponse'
    { $sel:vpcAttachment:GetVpcAttachmentResponse' :: Maybe VpcAttachment
vpcAttachment =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetVpcAttachmentResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Returns details about a VPC attachment.
getVpcAttachmentResponse_vpcAttachment :: Lens.Lens' GetVpcAttachmentResponse (Prelude.Maybe VpcAttachment)
getVpcAttachmentResponse_vpcAttachment :: Lens' GetVpcAttachmentResponse (Maybe VpcAttachment)
getVpcAttachmentResponse_vpcAttachment = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetVpcAttachmentResponse' {Maybe VpcAttachment
vpcAttachment :: Maybe VpcAttachment
$sel:vpcAttachment:GetVpcAttachmentResponse' :: GetVpcAttachmentResponse -> Maybe VpcAttachment
vpcAttachment} -> Maybe VpcAttachment
vpcAttachment) (\s :: GetVpcAttachmentResponse
s@GetVpcAttachmentResponse' {} Maybe VpcAttachment
a -> GetVpcAttachmentResponse
s {$sel:vpcAttachment:GetVpcAttachmentResponse' :: Maybe VpcAttachment
vpcAttachment = Maybe VpcAttachment
a} :: GetVpcAttachmentResponse)

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

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