{-# 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.DirectConnect.CreatePublicVirtualInterface
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a public virtual interface. A virtual interface is the VLAN that
-- transports Direct Connect traffic. A public virtual interface supports
-- sending traffic to public services of Amazon Web Services such as Amazon
-- S3.
--
-- When creating an IPv6 public virtual interface (@addressFamily@ is
-- @ipv6@), leave the @customer@ and @amazon@ address fields blank to use
-- auto-assigned IPv6 space. Custom IPv6 addresses are not supported.
module Amazonka.DirectConnect.CreatePublicVirtualInterface
  ( -- * Creating a Request
    CreatePublicVirtualInterface (..),
    newCreatePublicVirtualInterface,

    -- * Request Lenses
    createPublicVirtualInterface_connectionId,
    createPublicVirtualInterface_newPublicVirtualInterface,

    -- * Destructuring the Response
    VirtualInterface (..),
    newVirtualInterface,

    -- * Response Lenses
    virtualInterface_addressFamily,
    virtualInterface_amazonAddress,
    virtualInterface_amazonSideAsn,
    virtualInterface_asn,
    virtualInterface_authKey,
    virtualInterface_awsDeviceV2,
    virtualInterface_awsLogicalDeviceId,
    virtualInterface_bgpPeers,
    virtualInterface_connectionId,
    virtualInterface_customerAddress,
    virtualInterface_customerRouterConfig,
    virtualInterface_directConnectGatewayId,
    virtualInterface_jumboFrameCapable,
    virtualInterface_location,
    virtualInterface_mtu,
    virtualInterface_ownerAccount,
    virtualInterface_region,
    virtualInterface_routeFilterPrefixes,
    virtualInterface_siteLinkEnabled,
    virtualInterface_tags,
    virtualInterface_virtualGatewayId,
    virtualInterface_virtualInterfaceId,
    virtualInterface_virtualInterfaceName,
    virtualInterface_virtualInterfaceState,
    virtualInterface_virtualInterfaceType,
    virtualInterface_vlan,
  )
where

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

-- | /See:/ 'newCreatePublicVirtualInterface' smart constructor.
data CreatePublicVirtualInterface = CreatePublicVirtualInterface'
  { -- | The ID of the connection.
    CreatePublicVirtualInterface -> Text
connectionId :: Prelude.Text,
    -- | Information about the public virtual interface.
    CreatePublicVirtualInterface -> NewPublicVirtualInterface
newPublicVirtualInterface' :: NewPublicVirtualInterface
  }
  deriving (CreatePublicVirtualInterface
-> CreatePublicVirtualInterface -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreatePublicVirtualInterface
-> CreatePublicVirtualInterface -> Bool
$c/= :: CreatePublicVirtualInterface
-> CreatePublicVirtualInterface -> Bool
== :: CreatePublicVirtualInterface
-> CreatePublicVirtualInterface -> Bool
$c== :: CreatePublicVirtualInterface
-> CreatePublicVirtualInterface -> Bool
Prelude.Eq, ReadPrec [CreatePublicVirtualInterface]
ReadPrec CreatePublicVirtualInterface
Int -> ReadS CreatePublicVirtualInterface
ReadS [CreatePublicVirtualInterface]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreatePublicVirtualInterface]
$creadListPrec :: ReadPrec [CreatePublicVirtualInterface]
readPrec :: ReadPrec CreatePublicVirtualInterface
$creadPrec :: ReadPrec CreatePublicVirtualInterface
readList :: ReadS [CreatePublicVirtualInterface]
$creadList :: ReadS [CreatePublicVirtualInterface]
readsPrec :: Int -> ReadS CreatePublicVirtualInterface
$creadsPrec :: Int -> ReadS CreatePublicVirtualInterface
Prelude.Read, Int -> CreatePublicVirtualInterface -> ShowS
[CreatePublicVirtualInterface] -> ShowS
CreatePublicVirtualInterface -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreatePublicVirtualInterface] -> ShowS
$cshowList :: [CreatePublicVirtualInterface] -> ShowS
show :: CreatePublicVirtualInterface -> String
$cshow :: CreatePublicVirtualInterface -> String
showsPrec :: Int -> CreatePublicVirtualInterface -> ShowS
$cshowsPrec :: Int -> CreatePublicVirtualInterface -> ShowS
Prelude.Show, forall x.
Rep CreatePublicVirtualInterface x -> CreatePublicVirtualInterface
forall x.
CreatePublicVirtualInterface -> Rep CreatePublicVirtualInterface x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreatePublicVirtualInterface x -> CreatePublicVirtualInterface
$cfrom :: forall x.
CreatePublicVirtualInterface -> Rep CreatePublicVirtualInterface x
Prelude.Generic)

-- |
-- Create a value of 'CreatePublicVirtualInterface' 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:
--
-- 'connectionId', 'createPublicVirtualInterface_connectionId' - The ID of the connection.
--
-- 'newPublicVirtualInterface'', 'createPublicVirtualInterface_newPublicVirtualInterface' - Information about the public virtual interface.
newCreatePublicVirtualInterface ::
  -- | 'connectionId'
  Prelude.Text ->
  -- | 'newPublicVirtualInterface''
  NewPublicVirtualInterface ->
  CreatePublicVirtualInterface
newCreatePublicVirtualInterface :: Text -> NewPublicVirtualInterface -> CreatePublicVirtualInterface
newCreatePublicVirtualInterface
  Text
pConnectionId_
  NewPublicVirtualInterface
pNewPublicVirtualInterface_ =
    CreatePublicVirtualInterface'
      { $sel:connectionId:CreatePublicVirtualInterface' :: Text
connectionId =
          Text
pConnectionId_,
        $sel:newPublicVirtualInterface':CreatePublicVirtualInterface' :: NewPublicVirtualInterface
newPublicVirtualInterface' =
          NewPublicVirtualInterface
pNewPublicVirtualInterface_
      }

-- | The ID of the connection.
createPublicVirtualInterface_connectionId :: Lens.Lens' CreatePublicVirtualInterface Prelude.Text
createPublicVirtualInterface_connectionId :: Lens' CreatePublicVirtualInterface Text
createPublicVirtualInterface_connectionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePublicVirtualInterface' {Text
connectionId :: Text
$sel:connectionId:CreatePublicVirtualInterface' :: CreatePublicVirtualInterface -> Text
connectionId} -> Text
connectionId) (\s :: CreatePublicVirtualInterface
s@CreatePublicVirtualInterface' {} Text
a -> CreatePublicVirtualInterface
s {$sel:connectionId:CreatePublicVirtualInterface' :: Text
connectionId = Text
a} :: CreatePublicVirtualInterface)

-- | Information about the public virtual interface.
createPublicVirtualInterface_newPublicVirtualInterface :: Lens.Lens' CreatePublicVirtualInterface NewPublicVirtualInterface
createPublicVirtualInterface_newPublicVirtualInterface :: Lens' CreatePublicVirtualInterface NewPublicVirtualInterface
createPublicVirtualInterface_newPublicVirtualInterface = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePublicVirtualInterface' {NewPublicVirtualInterface
newPublicVirtualInterface' :: NewPublicVirtualInterface
$sel:newPublicVirtualInterface':CreatePublicVirtualInterface' :: CreatePublicVirtualInterface -> NewPublicVirtualInterface
newPublicVirtualInterface'} -> NewPublicVirtualInterface
newPublicVirtualInterface') (\s :: CreatePublicVirtualInterface
s@CreatePublicVirtualInterface' {} NewPublicVirtualInterface
a -> CreatePublicVirtualInterface
s {$sel:newPublicVirtualInterface':CreatePublicVirtualInterface' :: NewPublicVirtualInterface
newPublicVirtualInterface' = NewPublicVirtualInterface
a} :: CreatePublicVirtualInterface)

instance Core.AWSRequest CreatePublicVirtualInterface where
  type
    AWSResponse CreatePublicVirtualInterface =
      VirtualInterface
  request :: (Service -> Service)
-> CreatePublicVirtualInterface
-> Request CreatePublicVirtualInterface
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 CreatePublicVirtualInterface
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreatePublicVirtualInterface)))
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 -> forall a. FromJSON a => Object -> Either String a
Data.eitherParseJSON Object
x)

instance
  Prelude.Hashable
    CreatePublicVirtualInterface
  where
  hashWithSalt :: Int -> CreatePublicVirtualInterface -> Int
hashWithSalt Int
_salt CreatePublicVirtualInterface' {Text
NewPublicVirtualInterface
newPublicVirtualInterface' :: NewPublicVirtualInterface
connectionId :: Text
$sel:newPublicVirtualInterface':CreatePublicVirtualInterface' :: CreatePublicVirtualInterface -> NewPublicVirtualInterface
$sel:connectionId:CreatePublicVirtualInterface' :: CreatePublicVirtualInterface -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
connectionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NewPublicVirtualInterface
newPublicVirtualInterface'

instance Prelude.NFData CreatePublicVirtualInterface where
  rnf :: CreatePublicVirtualInterface -> ()
rnf CreatePublicVirtualInterface' {Text
NewPublicVirtualInterface
newPublicVirtualInterface' :: NewPublicVirtualInterface
connectionId :: Text
$sel:newPublicVirtualInterface':CreatePublicVirtualInterface' :: CreatePublicVirtualInterface -> NewPublicVirtualInterface
$sel:connectionId:CreatePublicVirtualInterface' :: CreatePublicVirtualInterface -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
connectionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NewPublicVirtualInterface
newPublicVirtualInterface'

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

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

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