{-# 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.MediaLive.Types.ChannelSummary
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.MediaLive.Types.ChannelSummary where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaLive.Types.CdiInputSpecification
import Amazonka.MediaLive.Types.ChannelClass
import Amazonka.MediaLive.Types.ChannelEgressEndpoint
import Amazonka.MediaLive.Types.ChannelState
import Amazonka.MediaLive.Types.InputAttachment
import Amazonka.MediaLive.Types.InputSpecification
import Amazonka.MediaLive.Types.LogLevel
import Amazonka.MediaLive.Types.OutputDestination
import Amazonka.MediaLive.Types.VpcOutputSettingsDescription
import qualified Amazonka.Prelude as Prelude

-- | Placeholder documentation for ChannelSummary
--
-- /See:/ 'newChannelSummary' smart constructor.
data ChannelSummary = ChannelSummary'
  { ChannelSummary -> Maybe ChannelState
state :: Prelude.Maybe ChannelState,
    -- | The log level being written to CloudWatch Logs.
    ChannelSummary -> Maybe LogLevel
logLevel :: Prelude.Maybe LogLevel,
    -- | The unique arn of the channel.
    ChannelSummary -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | The number of currently healthy pipelines.
    ChannelSummary -> Maybe Int
pipelinesRunningCount :: Prelude.Maybe Prelude.Int,
    -- | Specification of network and file inputs for this channel
    ChannelSummary -> Maybe InputSpecification
inputSpecification :: Prelude.Maybe InputSpecification,
    -- | List of input attachments for channel.
    ChannelSummary -> Maybe [InputAttachment]
inputAttachments :: Prelude.Maybe [InputAttachment],
    -- | A list of destinations of the channel. For UDP outputs, there is one
    -- destination per output. For other types (HLS, for example), there is one
    -- destination per packager.
    ChannelSummary -> Maybe [OutputDestination]
destinations :: Prelude.Maybe [OutputDestination],
    -- | The name of the channel. (user-mutable)
    ChannelSummary -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | Specification of CDI inputs for this channel
    ChannelSummary -> Maybe CdiInputSpecification
cdiInputSpecification :: Prelude.Maybe CdiInputSpecification,
    -- | The unique id of the channel.
    ChannelSummary -> Maybe Text
id :: Prelude.Maybe Prelude.Text,
    -- | The class for this channel. STANDARD for a channel with two pipelines or
    -- SINGLE_PIPELINE for a channel with one pipeline.
    ChannelSummary -> Maybe ChannelClass
channelClass :: Prelude.Maybe ChannelClass,
    -- | Settings for any VPC outputs.
    ChannelSummary -> Maybe VpcOutputSettingsDescription
vpc :: Prelude.Maybe VpcOutputSettingsDescription,
    -- | The endpoints where outgoing connections initiate from
    ChannelSummary -> Maybe [ChannelEgressEndpoint]
egressEndpoints :: Prelude.Maybe [ChannelEgressEndpoint],
    -- | A collection of key-value pairs.
    ChannelSummary -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The Amazon Resource Name (ARN) of the role assumed when running the
    -- Channel.
    ChannelSummary -> Maybe Text
roleArn :: Prelude.Maybe Prelude.Text
  }
  deriving (ChannelSummary -> ChannelSummary -> Bool
(ChannelSummary -> ChannelSummary -> Bool)
-> (ChannelSummary -> ChannelSummary -> Bool) -> Eq ChannelSummary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChannelSummary -> ChannelSummary -> Bool
$c/= :: ChannelSummary -> ChannelSummary -> Bool
== :: ChannelSummary -> ChannelSummary -> Bool
$c== :: ChannelSummary -> ChannelSummary -> Bool
Prelude.Eq, ReadPrec [ChannelSummary]
ReadPrec ChannelSummary
Int -> ReadS ChannelSummary
ReadS [ChannelSummary]
(Int -> ReadS ChannelSummary)
-> ReadS [ChannelSummary]
-> ReadPrec ChannelSummary
-> ReadPrec [ChannelSummary]
-> Read ChannelSummary
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ChannelSummary]
$creadListPrec :: ReadPrec [ChannelSummary]
readPrec :: ReadPrec ChannelSummary
$creadPrec :: ReadPrec ChannelSummary
readList :: ReadS [ChannelSummary]
$creadList :: ReadS [ChannelSummary]
readsPrec :: Int -> ReadS ChannelSummary
$creadsPrec :: Int -> ReadS ChannelSummary
Prelude.Read, Int -> ChannelSummary -> ShowS
[ChannelSummary] -> ShowS
ChannelSummary -> String
(Int -> ChannelSummary -> ShowS)
-> (ChannelSummary -> String)
-> ([ChannelSummary] -> ShowS)
-> Show ChannelSummary
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ChannelSummary] -> ShowS
$cshowList :: [ChannelSummary] -> ShowS
show :: ChannelSummary -> String
$cshow :: ChannelSummary -> String
showsPrec :: Int -> ChannelSummary -> ShowS
$cshowsPrec :: Int -> ChannelSummary -> ShowS
Prelude.Show, (forall x. ChannelSummary -> Rep ChannelSummary x)
-> (forall x. Rep ChannelSummary x -> ChannelSummary)
-> Generic ChannelSummary
forall x. Rep ChannelSummary x -> ChannelSummary
forall x. ChannelSummary -> Rep ChannelSummary x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ChannelSummary x -> ChannelSummary
$cfrom :: forall x. ChannelSummary -> Rep ChannelSummary x
Prelude.Generic)

-- |
-- Create a value of 'ChannelSummary' 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:
--
-- 'state', 'channelSummary_state' - Undocumented member.
--
-- 'logLevel', 'channelSummary_logLevel' - The log level being written to CloudWatch Logs.
--
-- 'arn', 'channelSummary_arn' - The unique arn of the channel.
--
-- 'pipelinesRunningCount', 'channelSummary_pipelinesRunningCount' - The number of currently healthy pipelines.
--
-- 'inputSpecification', 'channelSummary_inputSpecification' - Specification of network and file inputs for this channel
--
-- 'inputAttachments', 'channelSummary_inputAttachments' - List of input attachments for channel.
--
-- 'destinations', 'channelSummary_destinations' - A list of destinations of the channel. For UDP outputs, there is one
-- destination per output. For other types (HLS, for example), there is one
-- destination per packager.
--
-- 'name', 'channelSummary_name' - The name of the channel. (user-mutable)
--
-- 'cdiInputSpecification', 'channelSummary_cdiInputSpecification' - Specification of CDI inputs for this channel
--
-- 'id', 'channelSummary_id' - The unique id of the channel.
--
-- 'channelClass', 'channelSummary_channelClass' - The class for this channel. STANDARD for a channel with two pipelines or
-- SINGLE_PIPELINE for a channel with one pipeline.
--
-- 'vpc', 'channelSummary_vpc' - Settings for any VPC outputs.
--
-- 'egressEndpoints', 'channelSummary_egressEndpoints' - The endpoints where outgoing connections initiate from
--
-- 'tags', 'channelSummary_tags' - A collection of key-value pairs.
--
-- 'roleArn', 'channelSummary_roleArn' - The Amazon Resource Name (ARN) of the role assumed when running the
-- Channel.
newChannelSummary ::
  ChannelSummary
newChannelSummary :: ChannelSummary
newChannelSummary =
  ChannelSummary' :: Maybe ChannelState
-> Maybe LogLevel
-> Maybe Text
-> Maybe Int
-> Maybe InputSpecification
-> Maybe [InputAttachment]
-> Maybe [OutputDestination]
-> Maybe Text
-> Maybe CdiInputSpecification
-> Maybe Text
-> Maybe ChannelClass
-> Maybe VpcOutputSettingsDescription
-> Maybe [ChannelEgressEndpoint]
-> Maybe (HashMap Text Text)
-> Maybe Text
-> ChannelSummary
ChannelSummary'
    { $sel:state:ChannelSummary' :: Maybe ChannelState
state = Maybe ChannelState
forall a. Maybe a
Prelude.Nothing,
      $sel:logLevel:ChannelSummary' :: Maybe LogLevel
logLevel = Maybe LogLevel
forall a. Maybe a
Prelude.Nothing,
      $sel:arn:ChannelSummary' :: Maybe Text
arn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:pipelinesRunningCount:ChannelSummary' :: Maybe Int
pipelinesRunningCount = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:inputSpecification:ChannelSummary' :: Maybe InputSpecification
inputSpecification = Maybe InputSpecification
forall a. Maybe a
Prelude.Nothing,
      $sel:inputAttachments:ChannelSummary' :: Maybe [InputAttachment]
inputAttachments = Maybe [InputAttachment]
forall a. Maybe a
Prelude.Nothing,
      $sel:destinations:ChannelSummary' :: Maybe [OutputDestination]
destinations = Maybe [OutputDestination]
forall a. Maybe a
Prelude.Nothing,
      $sel:name:ChannelSummary' :: Maybe Text
name = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:cdiInputSpecification:ChannelSummary' :: Maybe CdiInputSpecification
cdiInputSpecification = Maybe CdiInputSpecification
forall a. Maybe a
Prelude.Nothing,
      $sel:id:ChannelSummary' :: Maybe Text
id = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:channelClass:ChannelSummary' :: Maybe ChannelClass
channelClass = Maybe ChannelClass
forall a. Maybe a
Prelude.Nothing,
      $sel:vpc:ChannelSummary' :: Maybe VpcOutputSettingsDescription
vpc = Maybe VpcOutputSettingsDescription
forall a. Maybe a
Prelude.Nothing,
      $sel:egressEndpoints:ChannelSummary' :: Maybe [ChannelEgressEndpoint]
egressEndpoints = Maybe [ChannelEgressEndpoint]
forall a. Maybe a
Prelude.Nothing,
      $sel:tags:ChannelSummary' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:roleArn:ChannelSummary' :: Maybe Text
roleArn = Maybe Text
forall a. Maybe a
Prelude.Nothing
    }

-- | Undocumented member.
channelSummary_state :: Lens.Lens' ChannelSummary (Prelude.Maybe ChannelState)
channelSummary_state :: (Maybe ChannelState -> f (Maybe ChannelState))
-> ChannelSummary -> f ChannelSummary
channelSummary_state = (ChannelSummary -> Maybe ChannelState)
-> (ChannelSummary -> Maybe ChannelState -> ChannelSummary)
-> Lens
     ChannelSummary
     ChannelSummary
     (Maybe ChannelState)
     (Maybe ChannelState)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe ChannelState
state :: Maybe ChannelState
$sel:state:ChannelSummary' :: ChannelSummary -> Maybe ChannelState
state} -> Maybe ChannelState
state) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe ChannelState
a -> ChannelSummary
s {$sel:state:ChannelSummary' :: Maybe ChannelState
state = Maybe ChannelState
a} :: ChannelSummary)

-- | The log level being written to CloudWatch Logs.
channelSummary_logLevel :: Lens.Lens' ChannelSummary (Prelude.Maybe LogLevel)
channelSummary_logLevel :: (Maybe LogLevel -> f (Maybe LogLevel))
-> ChannelSummary -> f ChannelSummary
channelSummary_logLevel = (ChannelSummary -> Maybe LogLevel)
-> (ChannelSummary -> Maybe LogLevel -> ChannelSummary)
-> Lens
     ChannelSummary ChannelSummary (Maybe LogLevel) (Maybe LogLevel)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe LogLevel
logLevel :: Maybe LogLevel
$sel:logLevel:ChannelSummary' :: ChannelSummary -> Maybe LogLevel
logLevel} -> Maybe LogLevel
logLevel) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe LogLevel
a -> ChannelSummary
s {$sel:logLevel:ChannelSummary' :: Maybe LogLevel
logLevel = Maybe LogLevel
a} :: ChannelSummary)

-- | The unique arn of the channel.
channelSummary_arn :: Lens.Lens' ChannelSummary (Prelude.Maybe Prelude.Text)
channelSummary_arn :: (Maybe Text -> f (Maybe Text))
-> ChannelSummary -> f ChannelSummary
channelSummary_arn = (ChannelSummary -> Maybe Text)
-> (ChannelSummary -> Maybe Text -> ChannelSummary)
-> Lens ChannelSummary ChannelSummary (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe Text
arn :: Maybe Text
$sel:arn:ChannelSummary' :: ChannelSummary -> Maybe Text
arn} -> Maybe Text
arn) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe Text
a -> ChannelSummary
s {$sel:arn:ChannelSummary' :: Maybe Text
arn = Maybe Text
a} :: ChannelSummary)

-- | The number of currently healthy pipelines.
channelSummary_pipelinesRunningCount :: Lens.Lens' ChannelSummary (Prelude.Maybe Prelude.Int)
channelSummary_pipelinesRunningCount :: (Maybe Int -> f (Maybe Int)) -> ChannelSummary -> f ChannelSummary
channelSummary_pipelinesRunningCount = (ChannelSummary -> Maybe Int)
-> (ChannelSummary -> Maybe Int -> ChannelSummary)
-> Lens ChannelSummary ChannelSummary (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe Int
pipelinesRunningCount :: Maybe Int
$sel:pipelinesRunningCount:ChannelSummary' :: ChannelSummary -> Maybe Int
pipelinesRunningCount} -> Maybe Int
pipelinesRunningCount) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe Int
a -> ChannelSummary
s {$sel:pipelinesRunningCount:ChannelSummary' :: Maybe Int
pipelinesRunningCount = Maybe Int
a} :: ChannelSummary)

-- | Specification of network and file inputs for this channel
channelSummary_inputSpecification :: Lens.Lens' ChannelSummary (Prelude.Maybe InputSpecification)
channelSummary_inputSpecification :: (Maybe InputSpecification -> f (Maybe InputSpecification))
-> ChannelSummary -> f ChannelSummary
channelSummary_inputSpecification = (ChannelSummary -> Maybe InputSpecification)
-> (ChannelSummary -> Maybe InputSpecification -> ChannelSummary)
-> Lens
     ChannelSummary
     ChannelSummary
     (Maybe InputSpecification)
     (Maybe InputSpecification)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe InputSpecification
inputSpecification :: Maybe InputSpecification
$sel:inputSpecification:ChannelSummary' :: ChannelSummary -> Maybe InputSpecification
inputSpecification} -> Maybe InputSpecification
inputSpecification) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe InputSpecification
a -> ChannelSummary
s {$sel:inputSpecification:ChannelSummary' :: Maybe InputSpecification
inputSpecification = Maybe InputSpecification
a} :: ChannelSummary)

-- | List of input attachments for channel.
channelSummary_inputAttachments :: Lens.Lens' ChannelSummary (Prelude.Maybe [InputAttachment])
channelSummary_inputAttachments :: (Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
-> ChannelSummary -> f ChannelSummary
channelSummary_inputAttachments = (ChannelSummary -> Maybe [InputAttachment])
-> (ChannelSummary -> Maybe [InputAttachment] -> ChannelSummary)
-> Lens
     ChannelSummary
     ChannelSummary
     (Maybe [InputAttachment])
     (Maybe [InputAttachment])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe [InputAttachment]
inputAttachments :: Maybe [InputAttachment]
$sel:inputAttachments:ChannelSummary' :: ChannelSummary -> Maybe [InputAttachment]
inputAttachments} -> Maybe [InputAttachment]
inputAttachments) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe [InputAttachment]
a -> ChannelSummary
s {$sel:inputAttachments:ChannelSummary' :: Maybe [InputAttachment]
inputAttachments = Maybe [InputAttachment]
a} :: ChannelSummary) ((Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
 -> ChannelSummary -> f ChannelSummary)
-> ((Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
    -> Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
-> (Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
-> ChannelSummary
-> f ChannelSummary
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [InputAttachment]
  [InputAttachment]
  [InputAttachment]
  [InputAttachment]
-> Iso
     (Maybe [InputAttachment])
     (Maybe [InputAttachment])
     (Maybe [InputAttachment])
     (Maybe [InputAttachment])
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 AnIso
  [InputAttachment]
  [InputAttachment]
  [InputAttachment]
  [InputAttachment]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of destinations of the channel. For UDP outputs, there is one
-- destination per output. For other types (HLS, for example), there is one
-- destination per packager.
channelSummary_destinations :: Lens.Lens' ChannelSummary (Prelude.Maybe [OutputDestination])
channelSummary_destinations :: (Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
-> ChannelSummary -> f ChannelSummary
channelSummary_destinations = (ChannelSummary -> Maybe [OutputDestination])
-> (ChannelSummary -> Maybe [OutputDestination] -> ChannelSummary)
-> Lens
     ChannelSummary
     ChannelSummary
     (Maybe [OutputDestination])
     (Maybe [OutputDestination])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe [OutputDestination]
destinations :: Maybe [OutputDestination]
$sel:destinations:ChannelSummary' :: ChannelSummary -> Maybe [OutputDestination]
destinations} -> Maybe [OutputDestination]
destinations) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe [OutputDestination]
a -> ChannelSummary
s {$sel:destinations:ChannelSummary' :: Maybe [OutputDestination]
destinations = Maybe [OutputDestination]
a} :: ChannelSummary) ((Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
 -> ChannelSummary -> f ChannelSummary)
-> ((Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
    -> Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
-> (Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
-> ChannelSummary
-> f ChannelSummary
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [OutputDestination]
  [OutputDestination]
  [OutputDestination]
  [OutputDestination]
-> Iso
     (Maybe [OutputDestination])
     (Maybe [OutputDestination])
     (Maybe [OutputDestination])
     (Maybe [OutputDestination])
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 AnIso
  [OutputDestination]
  [OutputDestination]
  [OutputDestination]
  [OutputDestination]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the channel. (user-mutable)
channelSummary_name :: Lens.Lens' ChannelSummary (Prelude.Maybe Prelude.Text)
channelSummary_name :: (Maybe Text -> f (Maybe Text))
-> ChannelSummary -> f ChannelSummary
channelSummary_name = (ChannelSummary -> Maybe Text)
-> (ChannelSummary -> Maybe Text -> ChannelSummary)
-> Lens ChannelSummary ChannelSummary (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe Text
name :: Maybe Text
$sel:name:ChannelSummary' :: ChannelSummary -> Maybe Text
name} -> Maybe Text
name) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe Text
a -> ChannelSummary
s {$sel:name:ChannelSummary' :: Maybe Text
name = Maybe Text
a} :: ChannelSummary)

-- | Specification of CDI inputs for this channel
channelSummary_cdiInputSpecification :: Lens.Lens' ChannelSummary (Prelude.Maybe CdiInputSpecification)
channelSummary_cdiInputSpecification :: (Maybe CdiInputSpecification -> f (Maybe CdiInputSpecification))
-> ChannelSummary -> f ChannelSummary
channelSummary_cdiInputSpecification = (ChannelSummary -> Maybe CdiInputSpecification)
-> (ChannelSummary
    -> Maybe CdiInputSpecification -> ChannelSummary)
-> Lens
     ChannelSummary
     ChannelSummary
     (Maybe CdiInputSpecification)
     (Maybe CdiInputSpecification)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe CdiInputSpecification
cdiInputSpecification :: Maybe CdiInputSpecification
$sel:cdiInputSpecification:ChannelSummary' :: ChannelSummary -> Maybe CdiInputSpecification
cdiInputSpecification} -> Maybe CdiInputSpecification
cdiInputSpecification) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe CdiInputSpecification
a -> ChannelSummary
s {$sel:cdiInputSpecification:ChannelSummary' :: Maybe CdiInputSpecification
cdiInputSpecification = Maybe CdiInputSpecification
a} :: ChannelSummary)

-- | The unique id of the channel.
channelSummary_id :: Lens.Lens' ChannelSummary (Prelude.Maybe Prelude.Text)
channelSummary_id :: (Maybe Text -> f (Maybe Text))
-> ChannelSummary -> f ChannelSummary
channelSummary_id = (ChannelSummary -> Maybe Text)
-> (ChannelSummary -> Maybe Text -> ChannelSummary)
-> Lens ChannelSummary ChannelSummary (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe Text
id :: Maybe Text
$sel:id:ChannelSummary' :: ChannelSummary -> Maybe Text
id} -> Maybe Text
id) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe Text
a -> ChannelSummary
s {$sel:id:ChannelSummary' :: Maybe Text
id = Maybe Text
a} :: ChannelSummary)

-- | The class for this channel. STANDARD for a channel with two pipelines or
-- SINGLE_PIPELINE for a channel with one pipeline.
channelSummary_channelClass :: Lens.Lens' ChannelSummary (Prelude.Maybe ChannelClass)
channelSummary_channelClass :: (Maybe ChannelClass -> f (Maybe ChannelClass))
-> ChannelSummary -> f ChannelSummary
channelSummary_channelClass = (ChannelSummary -> Maybe ChannelClass)
-> (ChannelSummary -> Maybe ChannelClass -> ChannelSummary)
-> Lens
     ChannelSummary
     ChannelSummary
     (Maybe ChannelClass)
     (Maybe ChannelClass)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe ChannelClass
channelClass :: Maybe ChannelClass
$sel:channelClass:ChannelSummary' :: ChannelSummary -> Maybe ChannelClass
channelClass} -> Maybe ChannelClass
channelClass) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe ChannelClass
a -> ChannelSummary
s {$sel:channelClass:ChannelSummary' :: Maybe ChannelClass
channelClass = Maybe ChannelClass
a} :: ChannelSummary)

-- | Settings for any VPC outputs.
channelSummary_vpc :: Lens.Lens' ChannelSummary (Prelude.Maybe VpcOutputSettingsDescription)
channelSummary_vpc :: (Maybe VpcOutputSettingsDescription
 -> f (Maybe VpcOutputSettingsDescription))
-> ChannelSummary -> f ChannelSummary
channelSummary_vpc = (ChannelSummary -> Maybe VpcOutputSettingsDescription)
-> (ChannelSummary
    -> Maybe VpcOutputSettingsDescription -> ChannelSummary)
-> Lens
     ChannelSummary
     ChannelSummary
     (Maybe VpcOutputSettingsDescription)
     (Maybe VpcOutputSettingsDescription)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe VpcOutputSettingsDescription
vpc :: Maybe VpcOutputSettingsDescription
$sel:vpc:ChannelSummary' :: ChannelSummary -> Maybe VpcOutputSettingsDescription
vpc} -> Maybe VpcOutputSettingsDescription
vpc) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe VpcOutputSettingsDescription
a -> ChannelSummary
s {$sel:vpc:ChannelSummary' :: Maybe VpcOutputSettingsDescription
vpc = Maybe VpcOutputSettingsDescription
a} :: ChannelSummary)

-- | The endpoints where outgoing connections initiate from
channelSummary_egressEndpoints :: Lens.Lens' ChannelSummary (Prelude.Maybe [ChannelEgressEndpoint])
channelSummary_egressEndpoints :: (Maybe [ChannelEgressEndpoint]
 -> f (Maybe [ChannelEgressEndpoint]))
-> ChannelSummary -> f ChannelSummary
channelSummary_egressEndpoints = (ChannelSummary -> Maybe [ChannelEgressEndpoint])
-> (ChannelSummary
    -> Maybe [ChannelEgressEndpoint] -> ChannelSummary)
-> Lens
     ChannelSummary
     ChannelSummary
     (Maybe [ChannelEgressEndpoint])
     (Maybe [ChannelEgressEndpoint])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe [ChannelEgressEndpoint]
egressEndpoints :: Maybe [ChannelEgressEndpoint]
$sel:egressEndpoints:ChannelSummary' :: ChannelSummary -> Maybe [ChannelEgressEndpoint]
egressEndpoints} -> Maybe [ChannelEgressEndpoint]
egressEndpoints) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe [ChannelEgressEndpoint]
a -> ChannelSummary
s {$sel:egressEndpoints:ChannelSummary' :: Maybe [ChannelEgressEndpoint]
egressEndpoints = Maybe [ChannelEgressEndpoint]
a} :: ChannelSummary) ((Maybe [ChannelEgressEndpoint]
  -> f (Maybe [ChannelEgressEndpoint]))
 -> ChannelSummary -> f ChannelSummary)
-> ((Maybe [ChannelEgressEndpoint]
     -> f (Maybe [ChannelEgressEndpoint]))
    -> Maybe [ChannelEgressEndpoint]
    -> f (Maybe [ChannelEgressEndpoint]))
-> (Maybe [ChannelEgressEndpoint]
    -> f (Maybe [ChannelEgressEndpoint]))
-> ChannelSummary
-> f ChannelSummary
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ChannelEgressEndpoint]
  [ChannelEgressEndpoint]
  [ChannelEgressEndpoint]
  [ChannelEgressEndpoint]
-> Iso
     (Maybe [ChannelEgressEndpoint])
     (Maybe [ChannelEgressEndpoint])
     (Maybe [ChannelEgressEndpoint])
     (Maybe [ChannelEgressEndpoint])
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 AnIso
  [ChannelEgressEndpoint]
  [ChannelEgressEndpoint]
  [ChannelEgressEndpoint]
  [ChannelEgressEndpoint]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A collection of key-value pairs.
channelSummary_tags :: Lens.Lens' ChannelSummary (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
channelSummary_tags :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> ChannelSummary -> f ChannelSummary
channelSummary_tags = (ChannelSummary -> Maybe (HashMap Text Text))
-> (ChannelSummary -> Maybe (HashMap Text Text) -> ChannelSummary)
-> Lens
     ChannelSummary
     ChannelSummary
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:ChannelSummary' :: ChannelSummary -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe (HashMap Text Text)
a -> ChannelSummary
s {$sel:tags:ChannelSummary' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: ChannelSummary) ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
 -> ChannelSummary -> f ChannelSummary)
-> ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
    -> Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> ChannelSummary
-> f ChannelSummary
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
-> Iso
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
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 AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The Amazon Resource Name (ARN) of the role assumed when running the
-- Channel.
channelSummary_roleArn :: Lens.Lens' ChannelSummary (Prelude.Maybe Prelude.Text)
channelSummary_roleArn :: (Maybe Text -> f (Maybe Text))
-> ChannelSummary -> f ChannelSummary
channelSummary_roleArn = (ChannelSummary -> Maybe Text)
-> (ChannelSummary -> Maybe Text -> ChannelSummary)
-> Lens ChannelSummary ChannelSummary (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ChannelSummary' {Maybe Text
roleArn :: Maybe Text
$sel:roleArn:ChannelSummary' :: ChannelSummary -> Maybe Text
roleArn} -> Maybe Text
roleArn) (\s :: ChannelSummary
s@ChannelSummary' {} Maybe Text
a -> ChannelSummary
s {$sel:roleArn:ChannelSummary' :: Maybe Text
roleArn = Maybe Text
a} :: ChannelSummary)

instance Core.FromJSON ChannelSummary where
  parseJSON :: Value -> Parser ChannelSummary
parseJSON =
    String
-> (Object -> Parser ChannelSummary)
-> Value
-> Parser ChannelSummary
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"ChannelSummary"
      ( \Object
x ->
          Maybe ChannelState
-> Maybe LogLevel
-> Maybe Text
-> Maybe Int
-> Maybe InputSpecification
-> Maybe [InputAttachment]
-> Maybe [OutputDestination]
-> Maybe Text
-> Maybe CdiInputSpecification
-> Maybe Text
-> Maybe ChannelClass
-> Maybe VpcOutputSettingsDescription
-> Maybe [ChannelEgressEndpoint]
-> Maybe (HashMap Text Text)
-> Maybe Text
-> ChannelSummary
ChannelSummary'
            (Maybe ChannelState
 -> Maybe LogLevel
 -> Maybe Text
 -> Maybe Int
 -> Maybe InputSpecification
 -> Maybe [InputAttachment]
 -> Maybe [OutputDestination]
 -> Maybe Text
 -> Maybe CdiInputSpecification
 -> Maybe Text
 -> Maybe ChannelClass
 -> Maybe VpcOutputSettingsDescription
 -> Maybe [ChannelEgressEndpoint]
 -> Maybe (HashMap Text Text)
 -> Maybe Text
 -> ChannelSummary)
-> Parser (Maybe ChannelState)
-> Parser
     (Maybe LogLevel
      -> Maybe Text
      -> Maybe Int
      -> Maybe InputSpecification
      -> Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe ChannelState)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"state")
            Parser
  (Maybe LogLevel
   -> Maybe Text
   -> Maybe Int
   -> Maybe InputSpecification
   -> Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe LogLevel)
-> Parser
     (Maybe Text
      -> Maybe Int
      -> Maybe InputSpecification
      -> Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe LogLevel)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"logLevel")
            Parser
  (Maybe Text
   -> Maybe Int
   -> Maybe InputSpecification
   -> Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe Text)
-> Parser
     (Maybe Int
      -> Maybe InputSpecification
      -> Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"arn")
            Parser
  (Maybe Int
   -> Maybe InputSpecification
   -> Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe Int)
-> Parser
     (Maybe InputSpecification
      -> Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"pipelinesRunningCount")
            Parser
  (Maybe InputSpecification
   -> Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe InputSpecification)
-> Parser
     (Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe InputSpecification)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"inputSpecification")
            Parser
  (Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe [InputAttachment])
-> Parser
     (Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [InputAttachment]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"inputAttachments"
                            Parser (Maybe (Maybe [InputAttachment]))
-> Maybe [InputAttachment] -> Parser (Maybe [InputAttachment])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [InputAttachment]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe [OutputDestination])
-> Parser
     (Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [OutputDestination]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"destinations" Parser (Maybe (Maybe [OutputDestination]))
-> Maybe [OutputDestination] -> Parser (Maybe [OutputDestination])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [OutputDestination]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe Text)
-> Parser
     (Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"name")
            Parser
  (Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe CdiInputSpecification)
-> Parser
     (Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe CdiInputSpecification)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"cdiInputSpecification")
            Parser
  (Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe Text)
-> Parser
     (Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"id")
            Parser
  (Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe ChannelClass)
-> Parser
     (Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe ChannelClass)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"channelClass")
            Parser
  (Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> ChannelSummary)
-> Parser (Maybe VpcOutputSettingsDescription)
-> Parser
     (Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text) -> Maybe Text -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe VpcOutputSettingsDescription)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"vpc")
            Parser
  (Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text) -> Maybe Text -> ChannelSummary)
-> Parser (Maybe [ChannelEgressEndpoint])
-> Parser
     (Maybe (HashMap Text Text) -> Maybe Text -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [ChannelEgressEndpoint]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"egressEndpoints"
                            Parser (Maybe (Maybe [ChannelEgressEndpoint]))
-> Maybe [ChannelEgressEndpoint]
-> Parser (Maybe [ChannelEgressEndpoint])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [ChannelEgressEndpoint]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser (Maybe (HashMap Text Text) -> Maybe Text -> ChannelSummary)
-> Parser (Maybe (HashMap Text Text))
-> Parser (Maybe Text -> ChannelSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe (HashMap Text Text)))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"tags" Parser (Maybe (Maybe (HashMap Text Text)))
-> Maybe (HashMap Text Text) -> Parser (Maybe (HashMap Text Text))
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe (HashMap Text Text)
forall a. Monoid a => a
Prelude.mempty)
            Parser (Maybe Text -> ChannelSummary)
-> Parser (Maybe Text) -> Parser ChannelSummary
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"roleArn")
      )

instance Prelude.Hashable ChannelSummary

instance Prelude.NFData ChannelSummary