{-# 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.CoreNetwork
-- 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.CoreNetwork 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.CoreNetworkEdge
import Amazonka.NetworkManager.Types.CoreNetworkSegment
import Amazonka.NetworkManager.Types.CoreNetworkState
import Amazonka.NetworkManager.Types.Tag
import qualified Amazonka.Prelude as Prelude

-- | Describes a core network.
--
-- /See:/ 'newCoreNetwork' smart constructor.
data CoreNetwork = CoreNetwork'
  { -- | The ARN of a core network.
    CoreNetwork -> Maybe Text
coreNetworkArn :: Prelude.Maybe Prelude.Text,
    -- | The ID of a core network.
    CoreNetwork -> Maybe Text
coreNetworkId :: Prelude.Maybe Prelude.Text,
    -- | The timestamp when a core network was created.
    CoreNetwork -> Maybe POSIX
createdAt :: Prelude.Maybe Data.POSIX,
    -- | The description of a core network.
    CoreNetwork -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The edges within a core network.
    CoreNetwork -> Maybe [CoreNetworkEdge]
edges :: Prelude.Maybe [CoreNetworkEdge],
    -- | The ID of the global network that your core network is a part of.
    CoreNetwork -> Maybe Text
globalNetworkId :: Prelude.Maybe Prelude.Text,
    -- | The segments within a core network.
    CoreNetwork -> Maybe [CoreNetworkSegment]
segments :: Prelude.Maybe [CoreNetworkSegment],
    -- | The current state of a core network.
    CoreNetwork -> Maybe CoreNetworkState
state :: Prelude.Maybe CoreNetworkState,
    -- | The list of key-value tags associated with a core network.
    CoreNetwork -> Maybe [Tag]
tags :: Prelude.Maybe [Tag]
  }
  deriving (CoreNetwork -> CoreNetwork -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CoreNetwork -> CoreNetwork -> Bool
$c/= :: CoreNetwork -> CoreNetwork -> Bool
== :: CoreNetwork -> CoreNetwork -> Bool
$c== :: CoreNetwork -> CoreNetwork -> Bool
Prelude.Eq, ReadPrec [CoreNetwork]
ReadPrec CoreNetwork
Int -> ReadS CoreNetwork
ReadS [CoreNetwork]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CoreNetwork]
$creadListPrec :: ReadPrec [CoreNetwork]
readPrec :: ReadPrec CoreNetwork
$creadPrec :: ReadPrec CoreNetwork
readList :: ReadS [CoreNetwork]
$creadList :: ReadS [CoreNetwork]
readsPrec :: Int -> ReadS CoreNetwork
$creadsPrec :: Int -> ReadS CoreNetwork
Prelude.Read, Int -> CoreNetwork -> ShowS
[CoreNetwork] -> ShowS
CoreNetwork -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CoreNetwork] -> ShowS
$cshowList :: [CoreNetwork] -> ShowS
show :: CoreNetwork -> String
$cshow :: CoreNetwork -> String
showsPrec :: Int -> CoreNetwork -> ShowS
$cshowsPrec :: Int -> CoreNetwork -> ShowS
Prelude.Show, forall x. Rep CoreNetwork x -> CoreNetwork
forall x. CoreNetwork -> Rep CoreNetwork x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CoreNetwork x -> CoreNetwork
$cfrom :: forall x. CoreNetwork -> Rep CoreNetwork x
Prelude.Generic)

-- |
-- Create a value of 'CoreNetwork' 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', 'coreNetwork_coreNetworkArn' - The ARN of a core network.
--
-- 'coreNetworkId', 'coreNetwork_coreNetworkId' - The ID of a core network.
--
-- 'createdAt', 'coreNetwork_createdAt' - The timestamp when a core network was created.
--
-- 'description', 'coreNetwork_description' - The description of a core network.
--
-- 'edges', 'coreNetwork_edges' - The edges within a core network.
--
-- 'globalNetworkId', 'coreNetwork_globalNetworkId' - The ID of the global network that your core network is a part of.
--
-- 'segments', 'coreNetwork_segments' - The segments within a core network.
--
-- 'state', 'coreNetwork_state' - The current state of a core network.
--
-- 'tags', 'coreNetwork_tags' - The list of key-value tags associated with a core network.
newCoreNetwork ::
  CoreNetwork
newCoreNetwork :: CoreNetwork
newCoreNetwork =
  CoreNetwork'
    { $sel:coreNetworkArn:CoreNetwork' :: Maybe Text
coreNetworkArn = forall a. Maybe a
Prelude.Nothing,
      $sel:coreNetworkId:CoreNetwork' :: Maybe Text
coreNetworkId = forall a. Maybe a
Prelude.Nothing,
      $sel:createdAt:CoreNetwork' :: Maybe POSIX
createdAt = forall a. Maybe a
Prelude.Nothing,
      $sel:description:CoreNetwork' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:edges:CoreNetwork' :: Maybe [CoreNetworkEdge]
edges = forall a. Maybe a
Prelude.Nothing,
      $sel:globalNetworkId:CoreNetwork' :: Maybe Text
globalNetworkId = forall a. Maybe a
Prelude.Nothing,
      $sel:segments:CoreNetwork' :: Maybe [CoreNetworkSegment]
segments = forall a. Maybe a
Prelude.Nothing,
      $sel:state:CoreNetwork' :: Maybe CoreNetworkState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CoreNetwork' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing
    }

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

-- | The ID of a core network.
coreNetwork_coreNetworkId :: Lens.Lens' CoreNetwork (Prelude.Maybe Prelude.Text)
coreNetwork_coreNetworkId :: Lens' CoreNetwork (Maybe Text)
coreNetwork_coreNetworkId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoreNetwork' {Maybe Text
coreNetworkId :: Maybe Text
$sel:coreNetworkId:CoreNetwork' :: CoreNetwork -> Maybe Text
coreNetworkId} -> Maybe Text
coreNetworkId) (\s :: CoreNetwork
s@CoreNetwork' {} Maybe Text
a -> CoreNetwork
s {$sel:coreNetworkId:CoreNetwork' :: Maybe Text
coreNetworkId = Maybe Text
a} :: CoreNetwork)

-- | The timestamp when a core network was created.
coreNetwork_createdAt :: Lens.Lens' CoreNetwork (Prelude.Maybe Prelude.UTCTime)
coreNetwork_createdAt :: Lens' CoreNetwork (Maybe UTCTime)
coreNetwork_createdAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoreNetwork' {Maybe POSIX
createdAt :: Maybe POSIX
$sel:createdAt:CoreNetwork' :: CoreNetwork -> Maybe POSIX
createdAt} -> Maybe POSIX
createdAt) (\s :: CoreNetwork
s@CoreNetwork' {} Maybe POSIX
a -> CoreNetwork
s {$sel:createdAt:CoreNetwork' :: Maybe POSIX
createdAt = Maybe POSIX
a} :: CoreNetwork) 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 description of a core network.
coreNetwork_description :: Lens.Lens' CoreNetwork (Prelude.Maybe Prelude.Text)
coreNetwork_description :: Lens' CoreNetwork (Maybe Text)
coreNetwork_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoreNetwork' {Maybe Text
description :: Maybe Text
$sel:description:CoreNetwork' :: CoreNetwork -> Maybe Text
description} -> Maybe Text
description) (\s :: CoreNetwork
s@CoreNetwork' {} Maybe Text
a -> CoreNetwork
s {$sel:description:CoreNetwork' :: Maybe Text
description = Maybe Text
a} :: CoreNetwork)

-- | The edges within a core network.
coreNetwork_edges :: Lens.Lens' CoreNetwork (Prelude.Maybe [CoreNetworkEdge])
coreNetwork_edges :: Lens' CoreNetwork (Maybe [CoreNetworkEdge])
coreNetwork_edges = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoreNetwork' {Maybe [CoreNetworkEdge]
edges :: Maybe [CoreNetworkEdge]
$sel:edges:CoreNetwork' :: CoreNetwork -> Maybe [CoreNetworkEdge]
edges} -> Maybe [CoreNetworkEdge]
edges) (\s :: CoreNetwork
s@CoreNetwork' {} Maybe [CoreNetworkEdge]
a -> CoreNetwork
s {$sel:edges:CoreNetwork' :: Maybe [CoreNetworkEdge]
edges = Maybe [CoreNetworkEdge]
a} :: CoreNetwork) 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 global network that your core network is a part of.
coreNetwork_globalNetworkId :: Lens.Lens' CoreNetwork (Prelude.Maybe Prelude.Text)
coreNetwork_globalNetworkId :: Lens' CoreNetwork (Maybe Text)
coreNetwork_globalNetworkId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoreNetwork' {Maybe Text
globalNetworkId :: Maybe Text
$sel:globalNetworkId:CoreNetwork' :: CoreNetwork -> Maybe Text
globalNetworkId} -> Maybe Text
globalNetworkId) (\s :: CoreNetwork
s@CoreNetwork' {} Maybe Text
a -> CoreNetwork
s {$sel:globalNetworkId:CoreNetwork' :: Maybe Text
globalNetworkId = Maybe Text
a} :: CoreNetwork)

-- | The segments within a core network.
coreNetwork_segments :: Lens.Lens' CoreNetwork (Prelude.Maybe [CoreNetworkSegment])
coreNetwork_segments :: Lens' CoreNetwork (Maybe [CoreNetworkSegment])
coreNetwork_segments = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoreNetwork' {Maybe [CoreNetworkSegment]
segments :: Maybe [CoreNetworkSegment]
$sel:segments:CoreNetwork' :: CoreNetwork -> Maybe [CoreNetworkSegment]
segments} -> Maybe [CoreNetworkSegment]
segments) (\s :: CoreNetwork
s@CoreNetwork' {} Maybe [CoreNetworkSegment]
a -> CoreNetwork
s {$sel:segments:CoreNetwork' :: Maybe [CoreNetworkSegment]
segments = Maybe [CoreNetworkSegment]
a} :: CoreNetwork) 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 current state of a core network.
coreNetwork_state :: Lens.Lens' CoreNetwork (Prelude.Maybe CoreNetworkState)
coreNetwork_state :: Lens' CoreNetwork (Maybe CoreNetworkState)
coreNetwork_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoreNetwork' {Maybe CoreNetworkState
state :: Maybe CoreNetworkState
$sel:state:CoreNetwork' :: CoreNetwork -> Maybe CoreNetworkState
state} -> Maybe CoreNetworkState
state) (\s :: CoreNetwork
s@CoreNetwork' {} Maybe CoreNetworkState
a -> CoreNetwork
s {$sel:state:CoreNetwork' :: Maybe CoreNetworkState
state = Maybe CoreNetworkState
a} :: CoreNetwork)

-- | The list of key-value tags associated with a core network.
coreNetwork_tags :: Lens.Lens' CoreNetwork (Prelude.Maybe [Tag])
coreNetwork_tags :: Lens' CoreNetwork (Maybe [Tag])
coreNetwork_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoreNetwork' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CoreNetwork' :: CoreNetwork -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CoreNetwork
s@CoreNetwork' {} Maybe [Tag]
a -> CoreNetwork
s {$sel:tags:CoreNetwork' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CoreNetwork) 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 CoreNetwork where
  parseJSON :: Value -> Parser CoreNetwork
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"CoreNetwork"
      ( \Object
x ->
          Maybe Text
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe [CoreNetworkEdge]
-> Maybe Text
-> Maybe [CoreNetworkSegment]
-> Maybe CoreNetworkState
-> Maybe [Tag]
-> CoreNetwork
CoreNetwork'
            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
"Description")
            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
"Edges" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            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
"GlobalNetworkId")
            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
"Segments" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            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 CoreNetwork where
  hashWithSalt :: Int -> CoreNetwork -> Int
hashWithSalt Int
_salt CoreNetwork' {Maybe [CoreNetworkEdge]
Maybe [CoreNetworkSegment]
Maybe [Tag]
Maybe Text
Maybe POSIX
Maybe CoreNetworkState
tags :: Maybe [Tag]
state :: Maybe CoreNetworkState
segments :: Maybe [CoreNetworkSegment]
globalNetworkId :: Maybe Text
edges :: Maybe [CoreNetworkEdge]
description :: Maybe Text
createdAt :: Maybe POSIX
coreNetworkId :: Maybe Text
coreNetworkArn :: Maybe Text
$sel:tags:CoreNetwork' :: CoreNetwork -> Maybe [Tag]
$sel:state:CoreNetwork' :: CoreNetwork -> Maybe CoreNetworkState
$sel:segments:CoreNetwork' :: CoreNetwork -> Maybe [CoreNetworkSegment]
$sel:globalNetworkId:CoreNetwork' :: CoreNetwork -> Maybe Text
$sel:edges:CoreNetwork' :: CoreNetwork -> Maybe [CoreNetworkEdge]
$sel:description:CoreNetwork' :: CoreNetwork -> Maybe Text
$sel:createdAt:CoreNetwork' :: CoreNetwork -> Maybe POSIX
$sel:coreNetworkId:CoreNetwork' :: CoreNetwork -> Maybe Text
$sel:coreNetworkArn:CoreNetwork' :: CoreNetwork -> 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
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [CoreNetworkEdge]
edges
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
globalNetworkId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [CoreNetworkSegment]
segments
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CoreNetworkState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags

instance Prelude.NFData CoreNetwork where
  rnf :: CoreNetwork -> ()
rnf CoreNetwork' {Maybe [CoreNetworkEdge]
Maybe [CoreNetworkSegment]
Maybe [Tag]
Maybe Text
Maybe POSIX
Maybe CoreNetworkState
tags :: Maybe [Tag]
state :: Maybe CoreNetworkState
segments :: Maybe [CoreNetworkSegment]
globalNetworkId :: Maybe Text
edges :: Maybe [CoreNetworkEdge]
description :: Maybe Text
createdAt :: Maybe POSIX
coreNetworkId :: Maybe Text
coreNetworkArn :: Maybe Text
$sel:tags:CoreNetwork' :: CoreNetwork -> Maybe [Tag]
$sel:state:CoreNetwork' :: CoreNetwork -> Maybe CoreNetworkState
$sel:segments:CoreNetwork' :: CoreNetwork -> Maybe [CoreNetworkSegment]
$sel:globalNetworkId:CoreNetwork' :: CoreNetwork -> Maybe Text
$sel:edges:CoreNetwork' :: CoreNetwork -> Maybe [CoreNetworkEdge]
$sel:description:CoreNetwork' :: CoreNetwork -> Maybe Text
$sel:createdAt:CoreNetwork' :: CoreNetwork -> Maybe POSIX
$sel:coreNetworkId:CoreNetwork' :: CoreNetwork -> Maybe Text
$sel:coreNetworkArn:CoreNetwork' :: CoreNetwork -> 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
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [CoreNetworkEdge]
edges
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
globalNetworkId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [CoreNetworkSegment]
segments
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CoreNetworkState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags