{-# 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.EC2.Types.TrunkInterfaceAssociation
-- 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.EC2.Types.TrunkInterfaceAssociation where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Internal
import Amazonka.EC2.Types.InterfaceProtocolType
import Amazonka.EC2.Types.Tag
import qualified Amazonka.Prelude as Prelude

-- | Currently available in __limited preview only__. If you are interested
-- in using this feature, contact your account manager.
--
-- Information about an association between a branch network interface with
-- a trunk network interface.
--
-- /See:/ 'newTrunkInterfaceAssociation' smart constructor.
data TrunkInterfaceAssociation = TrunkInterfaceAssociation'
  { -- | The ID of the association.
    TrunkInterfaceAssociation -> Maybe Text
associationId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the branch network interface.
    TrunkInterfaceAssociation -> Maybe Text
branchInterfaceId :: Prelude.Maybe Prelude.Text,
    -- | The application key when you use the GRE protocol.
    TrunkInterfaceAssociation -> Maybe Int
greKey :: Prelude.Maybe Prelude.Int,
    -- | The interface protocol. Valid values are @VLAN@ and @GRE@.
    TrunkInterfaceAssociation -> Maybe InterfaceProtocolType
interfaceProtocol :: Prelude.Maybe InterfaceProtocolType,
    -- | The tags for the trunk interface association.
    TrunkInterfaceAssociation -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The ID of the trunk network interface.
    TrunkInterfaceAssociation -> Maybe Text
trunkInterfaceId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the VLAN when you use the VLAN protocol.
    TrunkInterfaceAssociation -> Maybe Int
vlanId :: Prelude.Maybe Prelude.Int
  }
  deriving (TrunkInterfaceAssociation -> TrunkInterfaceAssociation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TrunkInterfaceAssociation -> TrunkInterfaceAssociation -> Bool
$c/= :: TrunkInterfaceAssociation -> TrunkInterfaceAssociation -> Bool
== :: TrunkInterfaceAssociation -> TrunkInterfaceAssociation -> Bool
$c== :: TrunkInterfaceAssociation -> TrunkInterfaceAssociation -> Bool
Prelude.Eq, ReadPrec [TrunkInterfaceAssociation]
ReadPrec TrunkInterfaceAssociation
Int -> ReadS TrunkInterfaceAssociation
ReadS [TrunkInterfaceAssociation]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TrunkInterfaceAssociation]
$creadListPrec :: ReadPrec [TrunkInterfaceAssociation]
readPrec :: ReadPrec TrunkInterfaceAssociation
$creadPrec :: ReadPrec TrunkInterfaceAssociation
readList :: ReadS [TrunkInterfaceAssociation]
$creadList :: ReadS [TrunkInterfaceAssociation]
readsPrec :: Int -> ReadS TrunkInterfaceAssociation
$creadsPrec :: Int -> ReadS TrunkInterfaceAssociation
Prelude.Read, Int -> TrunkInterfaceAssociation -> ShowS
[TrunkInterfaceAssociation] -> ShowS
TrunkInterfaceAssociation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TrunkInterfaceAssociation] -> ShowS
$cshowList :: [TrunkInterfaceAssociation] -> ShowS
show :: TrunkInterfaceAssociation -> String
$cshow :: TrunkInterfaceAssociation -> String
showsPrec :: Int -> TrunkInterfaceAssociation -> ShowS
$cshowsPrec :: Int -> TrunkInterfaceAssociation -> ShowS
Prelude.Show, forall x.
Rep TrunkInterfaceAssociation x -> TrunkInterfaceAssociation
forall x.
TrunkInterfaceAssociation -> Rep TrunkInterfaceAssociation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep TrunkInterfaceAssociation x -> TrunkInterfaceAssociation
$cfrom :: forall x.
TrunkInterfaceAssociation -> Rep TrunkInterfaceAssociation x
Prelude.Generic)

-- |
-- Create a value of 'TrunkInterfaceAssociation' 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:
--
-- 'associationId', 'trunkInterfaceAssociation_associationId' - The ID of the association.
--
-- 'branchInterfaceId', 'trunkInterfaceAssociation_branchInterfaceId' - The ID of the branch network interface.
--
-- 'greKey', 'trunkInterfaceAssociation_greKey' - The application key when you use the GRE protocol.
--
-- 'interfaceProtocol', 'trunkInterfaceAssociation_interfaceProtocol' - The interface protocol. Valid values are @VLAN@ and @GRE@.
--
-- 'tags', 'trunkInterfaceAssociation_tags' - The tags for the trunk interface association.
--
-- 'trunkInterfaceId', 'trunkInterfaceAssociation_trunkInterfaceId' - The ID of the trunk network interface.
--
-- 'vlanId', 'trunkInterfaceAssociation_vlanId' - The ID of the VLAN when you use the VLAN protocol.
newTrunkInterfaceAssociation ::
  TrunkInterfaceAssociation
newTrunkInterfaceAssociation :: TrunkInterfaceAssociation
newTrunkInterfaceAssociation =
  TrunkInterfaceAssociation'
    { $sel:associationId:TrunkInterfaceAssociation' :: Maybe Text
associationId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:branchInterfaceId:TrunkInterfaceAssociation' :: Maybe Text
branchInterfaceId = forall a. Maybe a
Prelude.Nothing,
      $sel:greKey:TrunkInterfaceAssociation' :: Maybe Int
greKey = forall a. Maybe a
Prelude.Nothing,
      $sel:interfaceProtocol:TrunkInterfaceAssociation' :: Maybe InterfaceProtocolType
interfaceProtocol = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:TrunkInterfaceAssociation' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:trunkInterfaceId:TrunkInterfaceAssociation' :: Maybe Text
trunkInterfaceId = forall a. Maybe a
Prelude.Nothing,
      $sel:vlanId:TrunkInterfaceAssociation' :: Maybe Int
vlanId = forall a. Maybe a
Prelude.Nothing
    }

-- | The ID of the association.
trunkInterfaceAssociation_associationId :: Lens.Lens' TrunkInterfaceAssociation (Prelude.Maybe Prelude.Text)
trunkInterfaceAssociation_associationId :: Lens' TrunkInterfaceAssociation (Maybe Text)
trunkInterfaceAssociation_associationId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TrunkInterfaceAssociation' {Maybe Text
associationId :: Maybe Text
$sel:associationId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Text
associationId} -> Maybe Text
associationId) (\s :: TrunkInterfaceAssociation
s@TrunkInterfaceAssociation' {} Maybe Text
a -> TrunkInterfaceAssociation
s {$sel:associationId:TrunkInterfaceAssociation' :: Maybe Text
associationId = Maybe Text
a} :: TrunkInterfaceAssociation)

-- | The ID of the branch network interface.
trunkInterfaceAssociation_branchInterfaceId :: Lens.Lens' TrunkInterfaceAssociation (Prelude.Maybe Prelude.Text)
trunkInterfaceAssociation_branchInterfaceId :: Lens' TrunkInterfaceAssociation (Maybe Text)
trunkInterfaceAssociation_branchInterfaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TrunkInterfaceAssociation' {Maybe Text
branchInterfaceId :: Maybe Text
$sel:branchInterfaceId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Text
branchInterfaceId} -> Maybe Text
branchInterfaceId) (\s :: TrunkInterfaceAssociation
s@TrunkInterfaceAssociation' {} Maybe Text
a -> TrunkInterfaceAssociation
s {$sel:branchInterfaceId:TrunkInterfaceAssociation' :: Maybe Text
branchInterfaceId = Maybe Text
a} :: TrunkInterfaceAssociation)

-- | The application key when you use the GRE protocol.
trunkInterfaceAssociation_greKey :: Lens.Lens' TrunkInterfaceAssociation (Prelude.Maybe Prelude.Int)
trunkInterfaceAssociation_greKey :: Lens' TrunkInterfaceAssociation (Maybe Int)
trunkInterfaceAssociation_greKey = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TrunkInterfaceAssociation' {Maybe Int
greKey :: Maybe Int
$sel:greKey:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Int
greKey} -> Maybe Int
greKey) (\s :: TrunkInterfaceAssociation
s@TrunkInterfaceAssociation' {} Maybe Int
a -> TrunkInterfaceAssociation
s {$sel:greKey:TrunkInterfaceAssociation' :: Maybe Int
greKey = Maybe Int
a} :: TrunkInterfaceAssociation)

-- | The interface protocol. Valid values are @VLAN@ and @GRE@.
trunkInterfaceAssociation_interfaceProtocol :: Lens.Lens' TrunkInterfaceAssociation (Prelude.Maybe InterfaceProtocolType)
trunkInterfaceAssociation_interfaceProtocol :: Lens' TrunkInterfaceAssociation (Maybe InterfaceProtocolType)
trunkInterfaceAssociation_interfaceProtocol = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TrunkInterfaceAssociation' {Maybe InterfaceProtocolType
interfaceProtocol :: Maybe InterfaceProtocolType
$sel:interfaceProtocol:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe InterfaceProtocolType
interfaceProtocol} -> Maybe InterfaceProtocolType
interfaceProtocol) (\s :: TrunkInterfaceAssociation
s@TrunkInterfaceAssociation' {} Maybe InterfaceProtocolType
a -> TrunkInterfaceAssociation
s {$sel:interfaceProtocol:TrunkInterfaceAssociation' :: Maybe InterfaceProtocolType
interfaceProtocol = Maybe InterfaceProtocolType
a} :: TrunkInterfaceAssociation)

-- | The tags for the trunk interface association.
trunkInterfaceAssociation_tags :: Lens.Lens' TrunkInterfaceAssociation (Prelude.Maybe [Tag])
trunkInterfaceAssociation_tags :: Lens' TrunkInterfaceAssociation (Maybe [Tag])
trunkInterfaceAssociation_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TrunkInterfaceAssociation' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: TrunkInterfaceAssociation
s@TrunkInterfaceAssociation' {} Maybe [Tag]
a -> TrunkInterfaceAssociation
s {$sel:tags:TrunkInterfaceAssociation' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: TrunkInterfaceAssociation) 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 ID of the trunk network interface.
trunkInterfaceAssociation_trunkInterfaceId :: Lens.Lens' TrunkInterfaceAssociation (Prelude.Maybe Prelude.Text)
trunkInterfaceAssociation_trunkInterfaceId :: Lens' TrunkInterfaceAssociation (Maybe Text)
trunkInterfaceAssociation_trunkInterfaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TrunkInterfaceAssociation' {Maybe Text
trunkInterfaceId :: Maybe Text
$sel:trunkInterfaceId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Text
trunkInterfaceId} -> Maybe Text
trunkInterfaceId) (\s :: TrunkInterfaceAssociation
s@TrunkInterfaceAssociation' {} Maybe Text
a -> TrunkInterfaceAssociation
s {$sel:trunkInterfaceId:TrunkInterfaceAssociation' :: Maybe Text
trunkInterfaceId = Maybe Text
a} :: TrunkInterfaceAssociation)

-- | The ID of the VLAN when you use the VLAN protocol.
trunkInterfaceAssociation_vlanId :: Lens.Lens' TrunkInterfaceAssociation (Prelude.Maybe Prelude.Int)
trunkInterfaceAssociation_vlanId :: Lens' TrunkInterfaceAssociation (Maybe Int)
trunkInterfaceAssociation_vlanId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TrunkInterfaceAssociation' {Maybe Int
vlanId :: Maybe Int
$sel:vlanId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Int
vlanId} -> Maybe Int
vlanId) (\s :: TrunkInterfaceAssociation
s@TrunkInterfaceAssociation' {} Maybe Int
a -> TrunkInterfaceAssociation
s {$sel:vlanId:TrunkInterfaceAssociation' :: Maybe Int
vlanId = Maybe Int
a} :: TrunkInterfaceAssociation)

instance Data.FromXML TrunkInterfaceAssociation where
  parseXML :: [Node] -> Either String TrunkInterfaceAssociation
parseXML [Node]
x =
    Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe InterfaceProtocolType
-> Maybe [Tag]
-> Maybe Text
-> Maybe Int
-> TrunkInterfaceAssociation
TrunkInterfaceAssociation'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"associationId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"branchInterfaceId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"greKey")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"interfaceProtocol")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"tagSet"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"trunkInterfaceId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"vlanId")

instance Prelude.Hashable TrunkInterfaceAssociation where
  hashWithSalt :: Int -> TrunkInterfaceAssociation -> Int
hashWithSalt Int
_salt TrunkInterfaceAssociation' {Maybe Int
Maybe [Tag]
Maybe Text
Maybe InterfaceProtocolType
vlanId :: Maybe Int
trunkInterfaceId :: Maybe Text
tags :: Maybe [Tag]
interfaceProtocol :: Maybe InterfaceProtocolType
greKey :: Maybe Int
branchInterfaceId :: Maybe Text
associationId :: Maybe Text
$sel:vlanId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Int
$sel:trunkInterfaceId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Text
$sel:tags:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe [Tag]
$sel:interfaceProtocol:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe InterfaceProtocolType
$sel:greKey:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Int
$sel:branchInterfaceId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Text
$sel:associationId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
associationId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
branchInterfaceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
greKey
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe InterfaceProtocolType
interfaceProtocol
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
trunkInterfaceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
vlanId

instance Prelude.NFData TrunkInterfaceAssociation where
  rnf :: TrunkInterfaceAssociation -> ()
rnf TrunkInterfaceAssociation' {Maybe Int
Maybe [Tag]
Maybe Text
Maybe InterfaceProtocolType
vlanId :: Maybe Int
trunkInterfaceId :: Maybe Text
tags :: Maybe [Tag]
interfaceProtocol :: Maybe InterfaceProtocolType
greKey :: Maybe Int
branchInterfaceId :: Maybe Text
associationId :: Maybe Text
$sel:vlanId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Int
$sel:trunkInterfaceId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Text
$sel:tags:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe [Tag]
$sel:interfaceProtocol:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe InterfaceProtocolType
$sel:greKey:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Int
$sel:branchInterfaceId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Text
$sel:associationId:TrunkInterfaceAssociation' :: TrunkInterfaceAssociation -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
associationId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
branchInterfaceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
greKey
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InterfaceProtocolType
interfaceProtocol
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
trunkInterfaceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
vlanId