{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# 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.Types.Peering
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.NetworkManager.Types.Peering 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.PeeringState
import Amazonka.NetworkManager.Types.PeeringType
import Amazonka.NetworkManager.Types.Tag
import qualified Amazonka.Prelude as Prelude

-- | Describes a peering connection.
--
-- /See:/ 'newPeering' smart constructor.
data Peering = Peering'
  { -- | The ARN of a core network.
    Peering -> Maybe Text
coreNetworkArn :: Prelude.Maybe Prelude.Text,
    -- | The ID of the core network for the peering request.
    Peering -> Maybe Text
coreNetworkId :: Prelude.Maybe Prelude.Text,
    -- | The timestamp when the attachment peer was created.
    Peering -> Maybe POSIX
createdAt :: Prelude.Maybe Data.POSIX,
    -- | The edge location for the peer.
    Peering -> Maybe Text
edgeLocation :: Prelude.Maybe Prelude.Text,
    -- | The ID of the account owner.
    Peering -> Maybe Text
ownerAccountId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the peering attachment.
    Peering -> Maybe Text
peeringId :: Prelude.Maybe Prelude.Text,
    -- | The type of peering. This will be @TRANSIT_GATEWAY@.
    Peering -> Maybe PeeringType
peeringType :: Prelude.Maybe PeeringType,
    -- | The resource ARN of the peer.
    Peering -> Maybe Text
resourceArn :: Prelude.Maybe Prelude.Text,
    -- | The current state of the peering connection.
    Peering -> Maybe PeeringState
state :: Prelude.Maybe PeeringState,
    -- | The list of key-value tags associated with the peering.
    Peering -> Maybe [Tag]
tags :: Prelude.Maybe [Tag]
  }
  deriving (Peering -> Peering -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Peering -> Peering -> Bool
$c/= :: Peering -> Peering -> Bool
== :: Peering -> Peering -> Bool
$c== :: Peering -> Peering -> Bool
Prelude.Eq, ReadPrec [Peering]
ReadPrec Peering
Int -> ReadS Peering
ReadS [Peering]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Peering]
$creadListPrec :: ReadPrec [Peering]
readPrec :: ReadPrec Peering
$creadPrec :: ReadPrec Peering
readList :: ReadS [Peering]
$creadList :: ReadS [Peering]
readsPrec :: Int -> ReadS Peering
$creadsPrec :: Int -> ReadS Peering
Prelude.Read, Int -> Peering -> ShowS
[Peering] -> ShowS
Peering -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Peering] -> ShowS
$cshowList :: [Peering] -> ShowS
show :: Peering -> String
$cshow :: Peering -> String
showsPrec :: Int -> Peering -> ShowS
$cshowsPrec :: Int -> Peering -> ShowS
Prelude.Show, forall x. Rep Peering x -> Peering
forall x. Peering -> Rep Peering x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Peering x -> Peering
$cfrom :: forall x. Peering -> Rep Peering x
Prelude.Generic)

-- |
-- Create a value of 'Peering' 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:
--
-- 'coreNetworkArn', 'peering_coreNetworkArn' - The ARN of a core network.
--
-- 'coreNetworkId', 'peering_coreNetworkId' - The ID of the core network for the peering request.
--
-- 'createdAt', 'peering_createdAt' - The timestamp when the attachment peer was created.
--
-- 'edgeLocation', 'peering_edgeLocation' - The edge location for the peer.
--
-- 'ownerAccountId', 'peering_ownerAccountId' - The ID of the account owner.
--
-- 'peeringId', 'peering_peeringId' - The ID of the peering attachment.
--
-- 'peeringType', 'peering_peeringType' - The type of peering. This will be @TRANSIT_GATEWAY@.
--
-- 'resourceArn', 'peering_resourceArn' - The resource ARN of the peer.
--
-- 'state', 'peering_state' - The current state of the peering connection.
--
-- 'tags', 'peering_tags' - The list of key-value tags associated with the peering.
newPeering ::
  Peering
newPeering :: Peering
newPeering =
  Peering'
    { $sel:coreNetworkArn:Peering' :: Maybe Text
coreNetworkArn = forall a. Maybe a
Prelude.Nothing,
      $sel:coreNetworkId:Peering' :: Maybe Text
coreNetworkId = forall a. Maybe a
Prelude.Nothing,
      $sel:createdAt:Peering' :: Maybe POSIX
createdAt = forall a. Maybe a
Prelude.Nothing,
      $sel:edgeLocation:Peering' :: Maybe Text
edgeLocation = forall a. Maybe a
Prelude.Nothing,
      $sel:ownerAccountId:Peering' :: Maybe Text
ownerAccountId = forall a. Maybe a
Prelude.Nothing,
      $sel:peeringId:Peering' :: Maybe Text
peeringId = forall a. Maybe a
Prelude.Nothing,
      $sel:peeringType:Peering' :: Maybe PeeringType
peeringType = forall a. Maybe a
Prelude.Nothing,
      $sel:resourceArn:Peering' :: Maybe Text
resourceArn = forall a. Maybe a
Prelude.Nothing,
      $sel:state:Peering' :: Maybe PeeringState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:Peering' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing
    }

-- | The ARN of a core network.
peering_coreNetworkArn :: Lens.Lens' Peering (Prelude.Maybe Prelude.Text)
peering_coreNetworkArn :: Lens' Peering (Maybe Text)
peering_coreNetworkArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe Text
coreNetworkArn :: Maybe Text
$sel:coreNetworkArn:Peering' :: Peering -> Maybe Text
coreNetworkArn} -> Maybe Text
coreNetworkArn) (\s :: Peering
s@Peering' {} Maybe Text
a -> Peering
s {$sel:coreNetworkArn:Peering' :: Maybe Text
coreNetworkArn = Maybe Text
a} :: Peering)

-- | The ID of the core network for the peering request.
peering_coreNetworkId :: Lens.Lens' Peering (Prelude.Maybe Prelude.Text)
peering_coreNetworkId :: Lens' Peering (Maybe Text)
peering_coreNetworkId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe Text
coreNetworkId :: Maybe Text
$sel:coreNetworkId:Peering' :: Peering -> Maybe Text
coreNetworkId} -> Maybe Text
coreNetworkId) (\s :: Peering
s@Peering' {} Maybe Text
a -> Peering
s {$sel:coreNetworkId:Peering' :: Maybe Text
coreNetworkId = Maybe Text
a} :: Peering)

-- | The timestamp when the attachment peer was created.
peering_createdAt :: Lens.Lens' Peering (Prelude.Maybe Prelude.UTCTime)
peering_createdAt :: Lens' Peering (Maybe UTCTime)
peering_createdAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe POSIX
createdAt :: Maybe POSIX
$sel:createdAt:Peering' :: Peering -> Maybe POSIX
createdAt} -> Maybe POSIX
createdAt) (\s :: Peering
s@Peering' {} Maybe POSIX
a -> Peering
s {$sel:createdAt:Peering' :: Maybe POSIX
createdAt = Maybe POSIX
a} :: Peering) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The edge location for the peer.
peering_edgeLocation :: Lens.Lens' Peering (Prelude.Maybe Prelude.Text)
peering_edgeLocation :: Lens' Peering (Maybe Text)
peering_edgeLocation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe Text
edgeLocation :: Maybe Text
$sel:edgeLocation:Peering' :: Peering -> Maybe Text
edgeLocation} -> Maybe Text
edgeLocation) (\s :: Peering
s@Peering' {} Maybe Text
a -> Peering
s {$sel:edgeLocation:Peering' :: Maybe Text
edgeLocation = Maybe Text
a} :: Peering)

-- | The ID of the account owner.
peering_ownerAccountId :: Lens.Lens' Peering (Prelude.Maybe Prelude.Text)
peering_ownerAccountId :: Lens' Peering (Maybe Text)
peering_ownerAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe Text
ownerAccountId :: Maybe Text
$sel:ownerAccountId:Peering' :: Peering -> Maybe Text
ownerAccountId} -> Maybe Text
ownerAccountId) (\s :: Peering
s@Peering' {} Maybe Text
a -> Peering
s {$sel:ownerAccountId:Peering' :: Maybe Text
ownerAccountId = Maybe Text
a} :: Peering)

-- | The ID of the peering attachment.
peering_peeringId :: Lens.Lens' Peering (Prelude.Maybe Prelude.Text)
peering_peeringId :: Lens' Peering (Maybe Text)
peering_peeringId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe Text
peeringId :: Maybe Text
$sel:peeringId:Peering' :: Peering -> Maybe Text
peeringId} -> Maybe Text
peeringId) (\s :: Peering
s@Peering' {} Maybe Text
a -> Peering
s {$sel:peeringId:Peering' :: Maybe Text
peeringId = Maybe Text
a} :: Peering)

-- | The type of peering. This will be @TRANSIT_GATEWAY@.
peering_peeringType :: Lens.Lens' Peering (Prelude.Maybe PeeringType)
peering_peeringType :: Lens' Peering (Maybe PeeringType)
peering_peeringType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe PeeringType
peeringType :: Maybe PeeringType
$sel:peeringType:Peering' :: Peering -> Maybe PeeringType
peeringType} -> Maybe PeeringType
peeringType) (\s :: Peering
s@Peering' {} Maybe PeeringType
a -> Peering
s {$sel:peeringType:Peering' :: Maybe PeeringType
peeringType = Maybe PeeringType
a} :: Peering)

-- | The resource ARN of the peer.
peering_resourceArn :: Lens.Lens' Peering (Prelude.Maybe Prelude.Text)
peering_resourceArn :: Lens' Peering (Maybe Text)
peering_resourceArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe Text
resourceArn :: Maybe Text
$sel:resourceArn:Peering' :: Peering -> Maybe Text
resourceArn} -> Maybe Text
resourceArn) (\s :: Peering
s@Peering' {} Maybe Text
a -> Peering
s {$sel:resourceArn:Peering' :: Maybe Text
resourceArn = Maybe Text
a} :: Peering)

-- | The current state of the peering connection.
peering_state :: Lens.Lens' Peering (Prelude.Maybe PeeringState)
peering_state :: Lens' Peering (Maybe PeeringState)
peering_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe PeeringState
state :: Maybe PeeringState
$sel:state:Peering' :: Peering -> Maybe PeeringState
state} -> Maybe PeeringState
state) (\s :: Peering
s@Peering' {} Maybe PeeringState
a -> Peering
s {$sel:state:Peering' :: Maybe PeeringState
state = Maybe PeeringState
a} :: Peering)

-- | The list of key-value tags associated with the peering.
peering_tags :: Lens.Lens' Peering (Prelude.Maybe [Tag])
peering_tags :: Lens' Peering (Maybe [Tag])
peering_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Peering' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:Peering' :: Peering -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: Peering
s@Peering' {} Maybe [Tag]
a -> Peering
s {$sel:tags:Peering' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: Peering) 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

instance Data.FromJSON Peering where
  parseJSON :: Value -> Parser Peering
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Peering"
      ( \Object
x ->
          Maybe Text
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe PeeringType
-> Maybe Text
-> Maybe PeeringState
-> Maybe [Tag]
-> Peering
Peering'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CoreNetworkArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CoreNetworkId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CreatedAt")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"EdgeLocation")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"OwnerAccountId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"PeeringId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"PeeringType")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ResourceArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"State")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Tags" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
      )

instance Prelude.Hashable Peering where
  hashWithSalt :: Int -> Peering -> Int
hashWithSalt Int
_salt Peering' {Maybe [Tag]
Maybe Text
Maybe POSIX
Maybe PeeringState
Maybe PeeringType
tags :: Maybe [Tag]
state :: Maybe PeeringState
resourceArn :: Maybe Text
peeringType :: Maybe PeeringType
peeringId :: Maybe Text
ownerAccountId :: Maybe Text
edgeLocation :: Maybe Text
createdAt :: Maybe POSIX
coreNetworkId :: Maybe Text
coreNetworkArn :: Maybe Text
$sel:tags:Peering' :: Peering -> Maybe [Tag]
$sel:state:Peering' :: Peering -> Maybe PeeringState
$sel:resourceArn:Peering' :: Peering -> Maybe Text
$sel:peeringType:Peering' :: Peering -> Maybe PeeringType
$sel:peeringId:Peering' :: Peering -> Maybe Text
$sel:ownerAccountId:Peering' :: Peering -> Maybe Text
$sel:edgeLocation:Peering' :: Peering -> Maybe Text
$sel:createdAt:Peering' :: Peering -> Maybe POSIX
$sel:coreNetworkId:Peering' :: Peering -> Maybe Text
$sel:coreNetworkArn:Peering' :: Peering -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
coreNetworkArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
coreNetworkId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
createdAt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
edgeLocation
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
ownerAccountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
peeringId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PeeringType
peeringType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
resourceArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PeeringState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags

instance Prelude.NFData Peering where
  rnf :: Peering -> ()
rnf Peering' {Maybe [Tag]
Maybe Text
Maybe POSIX
Maybe PeeringState
Maybe PeeringType
tags :: Maybe [Tag]
state :: Maybe PeeringState
resourceArn :: Maybe Text
peeringType :: Maybe PeeringType
peeringId :: Maybe Text
ownerAccountId :: Maybe Text
edgeLocation :: Maybe Text
createdAt :: Maybe POSIX
coreNetworkId :: Maybe Text
coreNetworkArn :: Maybe Text
$sel:tags:Peering' :: Peering -> Maybe [Tag]
$sel:state:Peering' :: Peering -> Maybe PeeringState
$sel:resourceArn:Peering' :: Peering -> Maybe Text
$sel:peeringType:Peering' :: Peering -> Maybe PeeringType
$sel:peeringId:Peering' :: Peering -> Maybe Text
$sel:ownerAccountId:Peering' :: Peering -> Maybe Text
$sel:edgeLocation:Peering' :: Peering -> Maybe Text
$sel:createdAt:Peering' :: Peering -> Maybe POSIX
$sel:coreNetworkId:Peering' :: Peering -> Maybe Text
$sel:coreNetworkArn:Peering' :: Peering -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
coreNetworkArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
coreNetworkId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
createdAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
edgeLocation
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
ownerAccountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
peeringId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PeeringType
peeringType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
resourceArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PeeringState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags