{-# 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.CreateInterconnect
-- 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 an interconnect between an Direct Connect Partner\'s network and
-- a specific Direct Connect location.
--
-- An interconnect is a connection that is capable of hosting other
-- connections. The Direct Connect Partner can use an interconnect to
-- provide Direct Connect hosted connections to customers through their own
-- network services. Like a standard connection, an interconnect links the
-- partner\'s network to an Direct Connect location over a standard
-- Ethernet fiber-optic cable. One end is connected to the partner\'s
-- router, the other to an Direct Connect router.
--
-- You can automatically add the new interconnect to a link aggregation
-- group (LAG) by specifying a LAG ID in the request. This ensures that the
-- new interconnect is allocated on the same Direct Connect endpoint that
-- hosts the specified LAG. If there are no available ports on the
-- endpoint, the request fails and no interconnect is created.
--
-- For each end customer, the Direct Connect Partner provisions a
-- connection on their interconnect by calling AllocateHostedConnection.
-- The end customer can then connect to Amazon Web Services resources by
-- creating a virtual interface on their connection, using the VLAN
-- assigned to them by the Direct Connect Partner.
--
-- Intended for use by Direct Connect Partners only.
module Amazonka.DirectConnect.CreateInterconnect
  ( -- * Creating a Request
    CreateInterconnect (..),
    newCreateInterconnect,

    -- * Request Lenses
    createInterconnect_lagId,
    createInterconnect_providerName,
    createInterconnect_tags,
    createInterconnect_interconnectName,
    createInterconnect_bandwidth,
    createInterconnect_location,

    -- * Destructuring the Response
    Interconnect (..),
    newInterconnect,

    -- * Response Lenses
    interconnect_awsDevice,
    interconnect_awsDeviceV2,
    interconnect_awsLogicalDeviceId,
    interconnect_bandwidth,
    interconnect_hasLogicalRedundancy,
    interconnect_interconnectId,
    interconnect_interconnectName,
    interconnect_interconnectState,
    interconnect_jumboFrameCapable,
    interconnect_lagId,
    interconnect_loaIssueTime,
    interconnect_location,
    interconnect_providerName,
    interconnect_region,
    interconnect_tags,
  )
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:/ 'newCreateInterconnect' smart constructor.
data CreateInterconnect = CreateInterconnect'
  { -- | The ID of the LAG.
    CreateInterconnect -> Maybe Text
lagId :: Prelude.Maybe Prelude.Text,
    -- | The name of the service provider associated with the interconnect.
    CreateInterconnect -> Maybe Text
providerName :: Prelude.Maybe Prelude.Text,
    -- | The tags to associate with the interconnect.
    CreateInterconnect -> Maybe (NonEmpty Tag)
tags :: Prelude.Maybe (Prelude.NonEmpty Tag),
    -- | The name of the interconnect.
    CreateInterconnect -> Text
interconnectName :: Prelude.Text,
    -- | The port bandwidth, in Gbps. The possible values are 1 and 10.
    CreateInterconnect -> Text
bandwidth :: Prelude.Text,
    -- | The location of the interconnect.
    CreateInterconnect -> Text
location :: Prelude.Text
  }
  deriving (CreateInterconnect -> CreateInterconnect -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateInterconnect -> CreateInterconnect -> Bool
$c/= :: CreateInterconnect -> CreateInterconnect -> Bool
== :: CreateInterconnect -> CreateInterconnect -> Bool
$c== :: CreateInterconnect -> CreateInterconnect -> Bool
Prelude.Eq, ReadPrec [CreateInterconnect]
ReadPrec CreateInterconnect
Int -> ReadS CreateInterconnect
ReadS [CreateInterconnect]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateInterconnect]
$creadListPrec :: ReadPrec [CreateInterconnect]
readPrec :: ReadPrec CreateInterconnect
$creadPrec :: ReadPrec CreateInterconnect
readList :: ReadS [CreateInterconnect]
$creadList :: ReadS [CreateInterconnect]
readsPrec :: Int -> ReadS CreateInterconnect
$creadsPrec :: Int -> ReadS CreateInterconnect
Prelude.Read, Int -> CreateInterconnect -> ShowS
[CreateInterconnect] -> ShowS
CreateInterconnect -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateInterconnect] -> ShowS
$cshowList :: [CreateInterconnect] -> ShowS
show :: CreateInterconnect -> String
$cshow :: CreateInterconnect -> String
showsPrec :: Int -> CreateInterconnect -> ShowS
$cshowsPrec :: Int -> CreateInterconnect -> ShowS
Prelude.Show, forall x. Rep CreateInterconnect x -> CreateInterconnect
forall x. CreateInterconnect -> Rep CreateInterconnect x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateInterconnect x -> CreateInterconnect
$cfrom :: forall x. CreateInterconnect -> Rep CreateInterconnect x
Prelude.Generic)

-- |
-- Create a value of 'CreateInterconnect' 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:
--
-- 'lagId', 'createInterconnect_lagId' - The ID of the LAG.
--
-- 'providerName', 'createInterconnect_providerName' - The name of the service provider associated with the interconnect.
--
-- 'tags', 'createInterconnect_tags' - The tags to associate with the interconnect.
--
-- 'interconnectName', 'createInterconnect_interconnectName' - The name of the interconnect.
--
-- 'bandwidth', 'createInterconnect_bandwidth' - The port bandwidth, in Gbps. The possible values are 1 and 10.
--
-- 'location', 'createInterconnect_location' - The location of the interconnect.
newCreateInterconnect ::
  -- | 'interconnectName'
  Prelude.Text ->
  -- | 'bandwidth'
  Prelude.Text ->
  -- | 'location'
  Prelude.Text ->
  CreateInterconnect
newCreateInterconnect :: Text -> Text -> Text -> CreateInterconnect
newCreateInterconnect
  Text
pInterconnectName_
  Text
pBandwidth_
  Text
pLocation_ =
    CreateInterconnect'
      { $sel:lagId:CreateInterconnect' :: Maybe Text
lagId = forall a. Maybe a
Prelude.Nothing,
        $sel:providerName:CreateInterconnect' :: Maybe Text
providerName = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateInterconnect' :: Maybe (NonEmpty Tag)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:interconnectName:CreateInterconnect' :: Text
interconnectName = Text
pInterconnectName_,
        $sel:bandwidth:CreateInterconnect' :: Text
bandwidth = Text
pBandwidth_,
        $sel:location:CreateInterconnect' :: Text
location = Text
pLocation_
      }

-- | The ID of the LAG.
createInterconnect_lagId :: Lens.Lens' CreateInterconnect (Prelude.Maybe Prelude.Text)
createInterconnect_lagId :: Lens' CreateInterconnect (Maybe Text)
createInterconnect_lagId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInterconnect' {Maybe Text
lagId :: Maybe Text
$sel:lagId:CreateInterconnect' :: CreateInterconnect -> Maybe Text
lagId} -> Maybe Text
lagId) (\s :: CreateInterconnect
s@CreateInterconnect' {} Maybe Text
a -> CreateInterconnect
s {$sel:lagId:CreateInterconnect' :: Maybe Text
lagId = Maybe Text
a} :: CreateInterconnect)

-- | The name of the service provider associated with the interconnect.
createInterconnect_providerName :: Lens.Lens' CreateInterconnect (Prelude.Maybe Prelude.Text)
createInterconnect_providerName :: Lens' CreateInterconnect (Maybe Text)
createInterconnect_providerName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInterconnect' {Maybe Text
providerName :: Maybe Text
$sel:providerName:CreateInterconnect' :: CreateInterconnect -> Maybe Text
providerName} -> Maybe Text
providerName) (\s :: CreateInterconnect
s@CreateInterconnect' {} Maybe Text
a -> CreateInterconnect
s {$sel:providerName:CreateInterconnect' :: Maybe Text
providerName = Maybe Text
a} :: CreateInterconnect)

-- | The tags to associate with the interconnect.
createInterconnect_tags :: Lens.Lens' CreateInterconnect (Prelude.Maybe (Prelude.NonEmpty Tag))
createInterconnect_tags :: Lens' CreateInterconnect (Maybe (NonEmpty Tag))
createInterconnect_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInterconnect' {Maybe (NonEmpty Tag)
tags :: Maybe (NonEmpty Tag)
$sel:tags:CreateInterconnect' :: CreateInterconnect -> Maybe (NonEmpty Tag)
tags} -> Maybe (NonEmpty Tag)
tags) (\s :: CreateInterconnect
s@CreateInterconnect' {} Maybe (NonEmpty Tag)
a -> CreateInterconnect
s {$sel:tags:CreateInterconnect' :: Maybe (NonEmpty Tag)
tags = Maybe (NonEmpty Tag)
a} :: CreateInterconnect) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the interconnect.
createInterconnect_interconnectName :: Lens.Lens' CreateInterconnect Prelude.Text
createInterconnect_interconnectName :: Lens' CreateInterconnect Text
createInterconnect_interconnectName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInterconnect' {Text
interconnectName :: Text
$sel:interconnectName:CreateInterconnect' :: CreateInterconnect -> Text
interconnectName} -> Text
interconnectName) (\s :: CreateInterconnect
s@CreateInterconnect' {} Text
a -> CreateInterconnect
s {$sel:interconnectName:CreateInterconnect' :: Text
interconnectName = Text
a} :: CreateInterconnect)

-- | The port bandwidth, in Gbps. The possible values are 1 and 10.
createInterconnect_bandwidth :: Lens.Lens' CreateInterconnect Prelude.Text
createInterconnect_bandwidth :: Lens' CreateInterconnect Text
createInterconnect_bandwidth = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInterconnect' {Text
bandwidth :: Text
$sel:bandwidth:CreateInterconnect' :: CreateInterconnect -> Text
bandwidth} -> Text
bandwidth) (\s :: CreateInterconnect
s@CreateInterconnect' {} Text
a -> CreateInterconnect
s {$sel:bandwidth:CreateInterconnect' :: Text
bandwidth = Text
a} :: CreateInterconnect)

-- | The location of the interconnect.
createInterconnect_location :: Lens.Lens' CreateInterconnect Prelude.Text
createInterconnect_location :: Lens' CreateInterconnect Text
createInterconnect_location = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInterconnect' {Text
location :: Text
$sel:location:CreateInterconnect' :: CreateInterconnect -> Text
location} -> Text
location) (\s :: CreateInterconnect
s@CreateInterconnect' {} Text
a -> CreateInterconnect
s {$sel:location:CreateInterconnect' :: Text
location = Text
a} :: CreateInterconnect)

instance Core.AWSRequest CreateInterconnect where
  type AWSResponse CreateInterconnect = Interconnect
  request :: (Service -> Service)
-> CreateInterconnect -> Request CreateInterconnect
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 CreateInterconnect
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateInterconnect)))
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 CreateInterconnect where
  hashWithSalt :: Int -> CreateInterconnect -> Int
hashWithSalt Int
_salt CreateInterconnect' {Maybe (NonEmpty Tag)
Maybe Text
Text
location :: Text
bandwidth :: Text
interconnectName :: Text
tags :: Maybe (NonEmpty Tag)
providerName :: Maybe Text
lagId :: Maybe Text
$sel:location:CreateInterconnect' :: CreateInterconnect -> Text
$sel:bandwidth:CreateInterconnect' :: CreateInterconnect -> Text
$sel:interconnectName:CreateInterconnect' :: CreateInterconnect -> Text
$sel:tags:CreateInterconnect' :: CreateInterconnect -> Maybe (NonEmpty Tag)
$sel:providerName:CreateInterconnect' :: CreateInterconnect -> Maybe Text
$sel:lagId:CreateInterconnect' :: CreateInterconnect -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
lagId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
providerName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Tag)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
interconnectName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
bandwidth
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
location

instance Prelude.NFData CreateInterconnect where
  rnf :: CreateInterconnect -> ()
rnf CreateInterconnect' {Maybe (NonEmpty Tag)
Maybe Text
Text
location :: Text
bandwidth :: Text
interconnectName :: Text
tags :: Maybe (NonEmpty Tag)
providerName :: Maybe Text
lagId :: Maybe Text
$sel:location:CreateInterconnect' :: CreateInterconnect -> Text
$sel:bandwidth:CreateInterconnect' :: CreateInterconnect -> Text
$sel:interconnectName:CreateInterconnect' :: CreateInterconnect -> Text
$sel:tags:CreateInterconnect' :: CreateInterconnect -> Maybe (NonEmpty Tag)
$sel:providerName:CreateInterconnect' :: CreateInterconnect -> Maybe Text
$sel:lagId:CreateInterconnect' :: CreateInterconnect -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
lagId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
providerName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Tag)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
interconnectName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
bandwidth
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
location

instance Data.ToHeaders CreateInterconnect where
  toHeaders :: CreateInterconnect -> 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.CreateInterconnect" ::
                          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 CreateInterconnect where
  toJSON :: CreateInterconnect -> Value
toJSON CreateInterconnect' {Maybe (NonEmpty Tag)
Maybe Text
Text
location :: Text
bandwidth :: Text
interconnectName :: Text
tags :: Maybe (NonEmpty Tag)
providerName :: Maybe Text
lagId :: Maybe Text
$sel:location:CreateInterconnect' :: CreateInterconnect -> Text
$sel:bandwidth:CreateInterconnect' :: CreateInterconnect -> Text
$sel:interconnectName:CreateInterconnect' :: CreateInterconnect -> Text
$sel:tags:CreateInterconnect' :: CreateInterconnect -> Maybe (NonEmpty Tag)
$sel:providerName:CreateInterconnect' :: CreateInterconnect -> Maybe Text
$sel:lagId:CreateInterconnect' :: CreateInterconnect -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"lagId" 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
lagId,
            (Key
"providerName" 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
providerName,
            (Key
"tags" 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 (NonEmpty Tag)
tags,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"interconnectName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
interconnectName),
            forall a. a -> Maybe a
Prelude.Just (Key
"bandwidth" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
bandwidth),
            forall a. a -> Maybe a
Prelude.Just (Key
"location" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
location)
          ]
      )

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

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