{-# 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.Channel
-- 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.Channel 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.EncoderSettings
import Amazonka.MediaLive.Types.InputAttachment
import Amazonka.MediaLive.Types.InputSpecification
import Amazonka.MediaLive.Types.LogLevel
import Amazonka.MediaLive.Types.OutputDestination
import Amazonka.MediaLive.Types.PipelineDetail
import Amazonka.MediaLive.Types.VpcOutputSettingsDescription
import qualified Amazonka.Prelude as Prelude

-- | Placeholder documentation for Channel
--
-- /See:/ 'newChannel' smart constructor.
data Channel = Channel'
  { Channel -> Maybe ChannelState
state :: Prelude.Maybe ChannelState,
    -- | The log level being written to CloudWatch Logs.
    Channel -> Maybe LogLevel
logLevel :: Prelude.Maybe LogLevel,
    -- | The unique arn of the channel.
    Channel -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | The number of currently healthy pipelines.
    Channel -> Maybe Int
pipelinesRunningCount :: Prelude.Maybe Prelude.Int,
    -- | Runtime details for the pipelines of a running channel.
    Channel -> Maybe [PipelineDetail]
pipelineDetails :: Prelude.Maybe [PipelineDetail],
    -- | Specification of network and file inputs for this channel
    Channel -> Maybe InputSpecification
inputSpecification :: Prelude.Maybe InputSpecification,
    -- | List of input attachments for channel.
    Channel -> 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.
    Channel -> Maybe [OutputDestination]
destinations :: Prelude.Maybe [OutputDestination],
    -- | The name of the channel. (user-mutable)
    Channel -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | Specification of CDI inputs for this channel
    Channel -> Maybe CdiInputSpecification
cdiInputSpecification :: Prelude.Maybe CdiInputSpecification,
    -- | The unique id of the channel.
    Channel -> 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.
    Channel -> Maybe ChannelClass
channelClass :: Prelude.Maybe ChannelClass,
    -- | Settings for VPC output
    Channel -> Maybe VpcOutputSettingsDescription
vpc :: Prelude.Maybe VpcOutputSettingsDescription,
    -- | The endpoints where outgoing connections initiate from
    Channel -> Maybe [ChannelEgressEndpoint]
egressEndpoints :: Prelude.Maybe [ChannelEgressEndpoint],
    -- | A collection of key-value pairs.
    Channel -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    Channel -> Maybe EncoderSettings
encoderSettings :: Prelude.Maybe EncoderSettings,
    -- | The Amazon Resource Name (ARN) of the role assumed when running the
    -- Channel.
    Channel -> Maybe Text
roleArn :: Prelude.Maybe Prelude.Text
  }
  deriving (Channel -> Channel -> Bool
(Channel -> Channel -> Bool)
-> (Channel -> Channel -> Bool) -> Eq Channel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Channel -> Channel -> Bool
$c/= :: Channel -> Channel -> Bool
== :: Channel -> Channel -> Bool
$c== :: Channel -> Channel -> Bool
Prelude.Eq, ReadPrec [Channel]
ReadPrec Channel
Int -> ReadS Channel
ReadS [Channel]
(Int -> ReadS Channel)
-> ReadS [Channel]
-> ReadPrec Channel
-> ReadPrec [Channel]
-> Read Channel
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Channel]
$creadListPrec :: ReadPrec [Channel]
readPrec :: ReadPrec Channel
$creadPrec :: ReadPrec Channel
readList :: ReadS [Channel]
$creadList :: ReadS [Channel]
readsPrec :: Int -> ReadS Channel
$creadsPrec :: Int -> ReadS Channel
Prelude.Read, Int -> Channel -> ShowS
[Channel] -> ShowS
Channel -> String
(Int -> Channel -> ShowS)
-> (Channel -> String) -> ([Channel] -> ShowS) -> Show Channel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Channel] -> ShowS
$cshowList :: [Channel] -> ShowS
show :: Channel -> String
$cshow :: Channel -> String
showsPrec :: Int -> Channel -> ShowS
$cshowsPrec :: Int -> Channel -> ShowS
Prelude.Show, (forall x. Channel -> Rep Channel x)
-> (forall x. Rep Channel x -> Channel) -> Generic Channel
forall x. Rep Channel x -> Channel
forall x. Channel -> Rep Channel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Channel x -> Channel
$cfrom :: forall x. Channel -> Rep Channel x
Prelude.Generic)

-- |
-- Create a value of 'Channel' 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', 'channel_state' - Undocumented member.
--
-- 'logLevel', 'channel_logLevel' - The log level being written to CloudWatch Logs.
--
-- 'arn', 'channel_arn' - The unique arn of the channel.
--
-- 'pipelinesRunningCount', 'channel_pipelinesRunningCount' - The number of currently healthy pipelines.
--
-- 'pipelineDetails', 'channel_pipelineDetails' - Runtime details for the pipelines of a running channel.
--
-- 'inputSpecification', 'channel_inputSpecification' - Specification of network and file inputs for this channel
--
-- 'inputAttachments', 'channel_inputAttachments' - List of input attachments for channel.
--
-- 'destinations', 'channel_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', 'channel_name' - The name of the channel. (user-mutable)
--
-- 'cdiInputSpecification', 'channel_cdiInputSpecification' - Specification of CDI inputs for this channel
--
-- 'id', 'channel_id' - The unique id of the channel.
--
-- 'channelClass', 'channel_channelClass' - The class for this channel. STANDARD for a channel with two pipelines or
-- SINGLE_PIPELINE for a channel with one pipeline.
--
-- 'vpc', 'channel_vpc' - Settings for VPC output
--
-- 'egressEndpoints', 'channel_egressEndpoints' - The endpoints where outgoing connections initiate from
--
-- 'tags', 'channel_tags' - A collection of key-value pairs.
--
-- 'encoderSettings', 'channel_encoderSettings' - Undocumented member.
--
-- 'roleArn', 'channel_roleArn' - The Amazon Resource Name (ARN) of the role assumed when running the
-- Channel.
newChannel ::
  Channel
newChannel :: Channel
newChannel =
  Channel' :: Maybe ChannelState
-> Maybe LogLevel
-> Maybe Text
-> Maybe Int
-> Maybe [PipelineDetail]
-> Maybe InputSpecification
-> Maybe [InputAttachment]
-> Maybe [OutputDestination]
-> Maybe Text
-> Maybe CdiInputSpecification
-> Maybe Text
-> Maybe ChannelClass
-> Maybe VpcOutputSettingsDescription
-> Maybe [ChannelEgressEndpoint]
-> Maybe (HashMap Text Text)
-> Maybe EncoderSettings
-> Maybe Text
-> Channel
Channel'
    { $sel:state:Channel' :: Maybe ChannelState
state = Maybe ChannelState
forall a. Maybe a
Prelude.Nothing,
      $sel:logLevel:Channel' :: Maybe LogLevel
logLevel = Maybe LogLevel
forall a. Maybe a
Prelude.Nothing,
      $sel:arn:Channel' :: Maybe Text
arn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:pipelinesRunningCount:Channel' :: Maybe Int
pipelinesRunningCount = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:pipelineDetails:Channel' :: Maybe [PipelineDetail]
pipelineDetails = Maybe [PipelineDetail]
forall a. Maybe a
Prelude.Nothing,
      $sel:inputSpecification:Channel' :: Maybe InputSpecification
inputSpecification = Maybe InputSpecification
forall a. Maybe a
Prelude.Nothing,
      $sel:inputAttachments:Channel' :: Maybe [InputAttachment]
inputAttachments = Maybe [InputAttachment]
forall a. Maybe a
Prelude.Nothing,
      $sel:destinations:Channel' :: Maybe [OutputDestination]
destinations = Maybe [OutputDestination]
forall a. Maybe a
Prelude.Nothing,
      $sel:name:Channel' :: Maybe Text
name = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:cdiInputSpecification:Channel' :: Maybe CdiInputSpecification
cdiInputSpecification = Maybe CdiInputSpecification
forall a. Maybe a
Prelude.Nothing,
      $sel:id:Channel' :: Maybe Text
id = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:channelClass:Channel' :: Maybe ChannelClass
channelClass = Maybe ChannelClass
forall a. Maybe a
Prelude.Nothing,
      $sel:vpc:Channel' :: Maybe VpcOutputSettingsDescription
vpc = Maybe VpcOutputSettingsDescription
forall a. Maybe a
Prelude.Nothing,
      $sel:egressEndpoints:Channel' :: Maybe [ChannelEgressEndpoint]
egressEndpoints = Maybe [ChannelEgressEndpoint]
forall a. Maybe a
Prelude.Nothing,
      $sel:tags:Channel' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:encoderSettings:Channel' :: Maybe EncoderSettings
encoderSettings = Maybe EncoderSettings
forall a. Maybe a
Prelude.Nothing,
      $sel:roleArn:Channel' :: Maybe Text
roleArn = Maybe Text
forall a. Maybe a
Prelude.Nothing
    }

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

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

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

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

-- | Runtime details for the pipelines of a running channel.
channel_pipelineDetails :: Lens.Lens' Channel (Prelude.Maybe [PipelineDetail])
channel_pipelineDetails :: (Maybe [PipelineDetail] -> f (Maybe [PipelineDetail]))
-> Channel -> f Channel
channel_pipelineDetails = (Channel -> Maybe [PipelineDetail])
-> (Channel -> Maybe [PipelineDetail] -> Channel)
-> Lens
     Channel Channel (Maybe [PipelineDetail]) (Maybe [PipelineDetail])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Channel' {Maybe [PipelineDetail]
pipelineDetails :: Maybe [PipelineDetail]
$sel:pipelineDetails:Channel' :: Channel -> Maybe [PipelineDetail]
pipelineDetails} -> Maybe [PipelineDetail]
pipelineDetails) (\s :: Channel
s@Channel' {} Maybe [PipelineDetail]
a -> Channel
s {$sel:pipelineDetails:Channel' :: Maybe [PipelineDetail]
pipelineDetails = Maybe [PipelineDetail]
a} :: Channel) ((Maybe [PipelineDetail] -> f (Maybe [PipelineDetail]))
 -> Channel -> f Channel)
-> ((Maybe [PipelineDetail] -> f (Maybe [PipelineDetail]))
    -> Maybe [PipelineDetail] -> f (Maybe [PipelineDetail]))
-> (Maybe [PipelineDetail] -> f (Maybe [PipelineDetail]))
-> Channel
-> f Channel
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [PipelineDetail] [PipelineDetail] [PipelineDetail] [PipelineDetail]
-> Iso
     (Maybe [PipelineDetail])
     (Maybe [PipelineDetail])
     (Maybe [PipelineDetail])
     (Maybe [PipelineDetail])
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
  [PipelineDetail] [PipelineDetail] [PipelineDetail] [PipelineDetail]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

-- | List of input attachments for channel.
channel_inputAttachments :: Lens.Lens' Channel (Prelude.Maybe [InputAttachment])
channel_inputAttachments :: (Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
-> Channel -> f Channel
channel_inputAttachments = (Channel -> Maybe [InputAttachment])
-> (Channel -> Maybe [InputAttachment] -> Channel)
-> Lens
     Channel Channel (Maybe [InputAttachment]) (Maybe [InputAttachment])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Channel' {Maybe [InputAttachment]
inputAttachments :: Maybe [InputAttachment]
$sel:inputAttachments:Channel' :: Channel -> Maybe [InputAttachment]
inputAttachments} -> Maybe [InputAttachment]
inputAttachments) (\s :: Channel
s@Channel' {} Maybe [InputAttachment]
a -> Channel
s {$sel:inputAttachments:Channel' :: Maybe [InputAttachment]
inputAttachments = Maybe [InputAttachment]
a} :: Channel) ((Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
 -> Channel -> f Channel)
-> ((Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
    -> Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
-> (Maybe [InputAttachment] -> f (Maybe [InputAttachment]))
-> Channel
-> f Channel
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.
channel_destinations :: Lens.Lens' Channel (Prelude.Maybe [OutputDestination])
channel_destinations :: (Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
-> Channel -> f Channel
channel_destinations = (Channel -> Maybe [OutputDestination])
-> (Channel -> Maybe [OutputDestination] -> Channel)
-> Lens
     Channel
     Channel
     (Maybe [OutputDestination])
     (Maybe [OutputDestination])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Channel' {Maybe [OutputDestination]
destinations :: Maybe [OutputDestination]
$sel:destinations:Channel' :: Channel -> Maybe [OutputDestination]
destinations} -> Maybe [OutputDestination]
destinations) (\s :: Channel
s@Channel' {} Maybe [OutputDestination]
a -> Channel
s {$sel:destinations:Channel' :: Maybe [OutputDestination]
destinations = Maybe [OutputDestination]
a} :: Channel) ((Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
 -> Channel -> f Channel)
-> ((Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
    -> Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
-> (Maybe [OutputDestination] -> f (Maybe [OutputDestination]))
-> Channel
-> f Channel
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)
channel_name :: Lens.Lens' Channel (Prelude.Maybe Prelude.Text)
channel_name :: (Maybe Text -> f (Maybe Text)) -> Channel -> f Channel
channel_name = (Channel -> Maybe Text)
-> (Channel -> Maybe Text -> Channel)
-> Lens Channel Channel (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Channel' {Maybe Text
name :: Maybe Text
$sel:name:Channel' :: Channel -> Maybe Text
name} -> Maybe Text
name) (\s :: Channel
s@Channel' {} Maybe Text
a -> Channel
s {$sel:name:Channel' :: Maybe Text
name = Maybe Text
a} :: Channel)

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

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

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

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

-- | The endpoints where outgoing connections initiate from
channel_egressEndpoints :: Lens.Lens' Channel (Prelude.Maybe [ChannelEgressEndpoint])
channel_egressEndpoints :: (Maybe [ChannelEgressEndpoint]
 -> f (Maybe [ChannelEgressEndpoint]))
-> Channel -> f Channel
channel_egressEndpoints = (Channel -> Maybe [ChannelEgressEndpoint])
-> (Channel -> Maybe [ChannelEgressEndpoint] -> Channel)
-> Lens
     Channel
     Channel
     (Maybe [ChannelEgressEndpoint])
     (Maybe [ChannelEgressEndpoint])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Channel' {Maybe [ChannelEgressEndpoint]
egressEndpoints :: Maybe [ChannelEgressEndpoint]
$sel:egressEndpoints:Channel' :: Channel -> Maybe [ChannelEgressEndpoint]
egressEndpoints} -> Maybe [ChannelEgressEndpoint]
egressEndpoints) (\s :: Channel
s@Channel' {} Maybe [ChannelEgressEndpoint]
a -> Channel
s {$sel:egressEndpoints:Channel' :: Maybe [ChannelEgressEndpoint]
egressEndpoints = Maybe [ChannelEgressEndpoint]
a} :: Channel) ((Maybe [ChannelEgressEndpoint]
  -> f (Maybe [ChannelEgressEndpoint]))
 -> Channel -> f Channel)
-> ((Maybe [ChannelEgressEndpoint]
     -> f (Maybe [ChannelEgressEndpoint]))
    -> Maybe [ChannelEgressEndpoint]
    -> f (Maybe [ChannelEgressEndpoint]))
-> (Maybe [ChannelEgressEndpoint]
    -> f (Maybe [ChannelEgressEndpoint]))
-> Channel
-> f Channel
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.
channel_tags :: Lens.Lens' Channel (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
channel_tags :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> Channel -> f Channel
channel_tags = (Channel -> Maybe (HashMap Text Text))
-> (Channel -> Maybe (HashMap Text Text) -> Channel)
-> Lens
     Channel
     Channel
     (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 (\Channel' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:Channel' :: Channel -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: Channel
s@Channel' {} Maybe (HashMap Text Text)
a -> Channel
s {$sel:tags:Channel' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: Channel) ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
 -> Channel -> f Channel)
-> ((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)))
-> Channel
-> f Channel
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

-- | Undocumented member.
channel_encoderSettings :: Lens.Lens' Channel (Prelude.Maybe EncoderSettings)
channel_encoderSettings :: (Maybe EncoderSettings -> f (Maybe EncoderSettings))
-> Channel -> f Channel
channel_encoderSettings = (Channel -> Maybe EncoderSettings)
-> (Channel -> Maybe EncoderSettings -> Channel)
-> Lens
     Channel Channel (Maybe EncoderSettings) (Maybe EncoderSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Channel' {Maybe EncoderSettings
encoderSettings :: Maybe EncoderSettings
$sel:encoderSettings:Channel' :: Channel -> Maybe EncoderSettings
encoderSettings} -> Maybe EncoderSettings
encoderSettings) (\s :: Channel
s@Channel' {} Maybe EncoderSettings
a -> Channel
s {$sel:encoderSettings:Channel' :: Maybe EncoderSettings
encoderSettings = Maybe EncoderSettings
a} :: Channel)

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

instance Core.FromJSON Channel where
  parseJSON :: Value -> Parser Channel
parseJSON =
    String -> (Object -> Parser Channel) -> Value -> Parser Channel
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"Channel"
      ( \Object
x ->
          Maybe ChannelState
-> Maybe LogLevel
-> Maybe Text
-> Maybe Int
-> Maybe [PipelineDetail]
-> Maybe InputSpecification
-> Maybe [InputAttachment]
-> Maybe [OutputDestination]
-> Maybe Text
-> Maybe CdiInputSpecification
-> Maybe Text
-> Maybe ChannelClass
-> Maybe VpcOutputSettingsDescription
-> Maybe [ChannelEgressEndpoint]
-> Maybe (HashMap Text Text)
-> Maybe EncoderSettings
-> Maybe Text
-> Channel
Channel'
            (Maybe ChannelState
 -> Maybe LogLevel
 -> Maybe Text
 -> Maybe Int
 -> Maybe [PipelineDetail]
 -> Maybe InputSpecification
 -> Maybe [InputAttachment]
 -> Maybe [OutputDestination]
 -> Maybe Text
 -> Maybe CdiInputSpecification
 -> Maybe Text
 -> Maybe ChannelClass
 -> Maybe VpcOutputSettingsDescription
 -> Maybe [ChannelEgressEndpoint]
 -> Maybe (HashMap Text Text)
 -> Maybe EncoderSettings
 -> Maybe Text
 -> Channel)
-> Parser (Maybe ChannelState)
-> Parser
     (Maybe LogLevel
      -> Maybe Text
      -> Maybe Int
      -> Maybe [PipelineDetail]
      -> Maybe InputSpecification
      -> Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 [PipelineDetail]
   -> Maybe InputSpecification
   -> Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe LogLevel)
-> Parser
     (Maybe Text
      -> Maybe Int
      -> Maybe [PipelineDetail]
      -> Maybe InputSpecification
      -> Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 [PipelineDetail]
   -> Maybe InputSpecification
   -> Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe Text)
-> Parser
     (Maybe Int
      -> Maybe [PipelineDetail]
      -> Maybe InputSpecification
      -> Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 [PipelineDetail]
   -> Maybe InputSpecification
   -> Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe Int)
-> Parser
     (Maybe [PipelineDetail]
      -> Maybe InputSpecification
      -> Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 [PipelineDetail]
   -> Maybe InputSpecification
   -> Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe [PipelineDetail])
-> Parser
     (Maybe InputSpecification
      -> Maybe [InputAttachment]
      -> Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [PipelineDetail]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"pipelineDetails"
                            Parser (Maybe (Maybe [PipelineDetail]))
-> Maybe [PipelineDetail] -> Parser (Maybe [PipelineDetail])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [PipelineDetail]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe InputSpecification
   -> Maybe [InputAttachment]
   -> Maybe [OutputDestination]
   -> Maybe Text
   -> Maybe CdiInputSpecification
   -> Maybe Text
   -> Maybe ChannelClass
   -> Maybe VpcOutputSettingsDescription
   -> Maybe [ChannelEgressEndpoint]
   -> Maybe (HashMap Text Text)
   -> Maybe EncoderSettings
   -> Maybe Text
   -> Channel)
-> 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 EncoderSettings
      -> Maybe Text
      -> Channel)
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 EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe [InputAttachment])
-> Parser
     (Maybe [OutputDestination]
      -> Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe [OutputDestination])
-> Parser
     (Maybe Text
      -> Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe Text)
-> Parser
     (Maybe CdiInputSpecification
      -> Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe CdiInputSpecification)
-> Parser
     (Maybe Text
      -> Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe Text)
-> Parser
     (Maybe ChannelClass
      -> Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe ChannelClass)
-> Parser
     (Maybe VpcOutputSettingsDescription
      -> Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe VpcOutputSettingsDescription)
-> Parser
     (Maybe [ChannelEgressEndpoint]
      -> Maybe (HashMap Text Text)
      -> Maybe EncoderSettings
      -> Maybe Text
      -> Channel)
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 EncoderSettings
   -> Maybe Text
   -> Channel)
-> Parser (Maybe [ChannelEgressEndpoint])
-> Parser
     (Maybe (HashMap Text Text)
      -> Maybe EncoderSettings -> Maybe Text -> Channel)
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 EncoderSettings -> Maybe Text -> Channel)
-> Parser (Maybe (HashMap Text Text))
-> Parser (Maybe EncoderSettings -> Maybe Text -> Channel)
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 EncoderSettings -> Maybe Text -> Channel)
-> Parser (Maybe EncoderSettings) -> Parser (Maybe Text -> Channel)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe EncoderSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"encoderSettings")
            Parser (Maybe Text -> Channel)
-> Parser (Maybe Text) -> Parser Channel
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 Channel

instance Prelude.NFData Channel