{-# 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.Input
-- 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.Input where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaLive.Types.InputClass
import Amazonka.MediaLive.Types.InputDestination
import Amazonka.MediaLive.Types.InputDeviceSettings
import Amazonka.MediaLive.Types.InputSource
import Amazonka.MediaLive.Types.InputSourceType
import Amazonka.MediaLive.Types.InputState
import Amazonka.MediaLive.Types.InputType
import Amazonka.MediaLive.Types.MediaConnectFlow
import qualified Amazonka.Prelude as Prelude

-- | Placeholder documentation for Input
--
-- /See:/ 'newInput' smart constructor.
data Input = Input'
  { Input -> Maybe InputState
state :: Prelude.Maybe InputState,
    -- | A list of IDs for all the Input Security Groups attached to the input.
    Input -> Maybe [Text]
securityGroups :: Prelude.Maybe [Prelude.Text],
    -- | The Unique ARN of the input (generated, immutable).
    Input -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | Settings for the input devices.
    Input -> Maybe [InputDeviceSettings]
inputDevices :: Prelude.Maybe [InputDeviceSettings],
    -- | A list of IDs for all Inputs which are partners of this one.
    Input -> Maybe [Text]
inputPartnerIds :: Prelude.Maybe [Prelude.Text],
    -- | A list of the sources of the input (PULL-type).
    Input -> Maybe [InputSource]
sources :: Prelude.Maybe [InputSource],
    -- | A list of the destinations of the input (PUSH-type).
    Input -> Maybe [InputDestination]
destinations :: Prelude.Maybe [InputDestination],
    -- | The user-assigned name (This is a mutable value).
    Input -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | A list of channel IDs that that input is attached to (currently an input
    -- can only be attached to one channel).
    Input -> Maybe [Text]
attachedChannels :: Prelude.Maybe [Prelude.Text],
    -- | The generated ID of the input (unique for user account, immutable).
    Input -> Maybe Text
id :: Prelude.Maybe Prelude.Text,
    -- | STANDARD - MediaLive expects two sources to be connected to this input.
    -- If the channel is also STANDARD, both sources will be ingested. If the
    -- channel is SINGLE_PIPELINE, only the first source will be ingested; the
    -- second source will always be ignored, even if the first source fails.
    -- SINGLE_PIPELINE - You can connect only one source to this input. If the
    -- ChannelClass is also SINGLE_PIPELINE, this value is valid. If the
    -- ChannelClass is STANDARD, this value is not valid because the channel
    -- requires two sources in the input.
    Input -> Maybe InputClass
inputClass :: Prelude.Maybe InputClass,
    Input -> Maybe InputType
type' :: Prelude.Maybe InputType,
    -- | A list of MediaConnect Flows for this input.
    Input -> Maybe [MediaConnectFlow]
mediaConnectFlows :: Prelude.Maybe [MediaConnectFlow],
    -- | Certain pull input sources can be dynamic, meaning that they can have
    -- their URL\'s dynamically changes during input switch actions. Presently,
    -- this functionality only works with MP4_FILE and TS_FILE inputs.
    Input -> Maybe InputSourceType
inputSourceType :: Prelude.Maybe InputSourceType,
    -- | A collection of key-value pairs.
    Input -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The Amazon Resource Name (ARN) of the role this input assumes during and
    -- after creation.
    Input -> Maybe Text
roleArn :: Prelude.Maybe Prelude.Text
  }
  deriving (Input -> Input -> Bool
(Input -> Input -> Bool) -> (Input -> Input -> Bool) -> Eq Input
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Input -> Input -> Bool
$c/= :: Input -> Input -> Bool
== :: Input -> Input -> Bool
$c== :: Input -> Input -> Bool
Prelude.Eq, ReadPrec [Input]
ReadPrec Input
Int -> ReadS Input
ReadS [Input]
(Int -> ReadS Input)
-> ReadS [Input]
-> ReadPrec Input
-> ReadPrec [Input]
-> Read Input
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Input]
$creadListPrec :: ReadPrec [Input]
readPrec :: ReadPrec Input
$creadPrec :: ReadPrec Input
readList :: ReadS [Input]
$creadList :: ReadS [Input]
readsPrec :: Int -> ReadS Input
$creadsPrec :: Int -> ReadS Input
Prelude.Read, Int -> Input -> ShowS
[Input] -> ShowS
Input -> String
(Int -> Input -> ShowS)
-> (Input -> String) -> ([Input] -> ShowS) -> Show Input
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Input] -> ShowS
$cshowList :: [Input] -> ShowS
show :: Input -> String
$cshow :: Input -> String
showsPrec :: Int -> Input -> ShowS
$cshowsPrec :: Int -> Input -> ShowS
Prelude.Show, (forall x. Input -> Rep Input x)
-> (forall x. Rep Input x -> Input) -> Generic Input
forall x. Rep Input x -> Input
forall x. Input -> Rep Input x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Input x -> Input
$cfrom :: forall x. Input -> Rep Input x
Prelude.Generic)

-- |
-- Create a value of 'Input' 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', 'input_state' - Undocumented member.
--
-- 'securityGroups', 'input_securityGroups' - A list of IDs for all the Input Security Groups attached to the input.
--
-- 'arn', 'input_arn' - The Unique ARN of the input (generated, immutable).
--
-- 'inputDevices', 'input_inputDevices' - Settings for the input devices.
--
-- 'inputPartnerIds', 'input_inputPartnerIds' - A list of IDs for all Inputs which are partners of this one.
--
-- 'sources', 'input_sources' - A list of the sources of the input (PULL-type).
--
-- 'destinations', 'input_destinations' - A list of the destinations of the input (PUSH-type).
--
-- 'name', 'input_name' - The user-assigned name (This is a mutable value).
--
-- 'attachedChannels', 'input_attachedChannels' - A list of channel IDs that that input is attached to (currently an input
-- can only be attached to one channel).
--
-- 'id', 'input_id' - The generated ID of the input (unique for user account, immutable).
--
-- 'inputClass', 'input_inputClass' - STANDARD - MediaLive expects two sources to be connected to this input.
-- If the channel is also STANDARD, both sources will be ingested. If the
-- channel is SINGLE_PIPELINE, only the first source will be ingested; the
-- second source will always be ignored, even if the first source fails.
-- SINGLE_PIPELINE - You can connect only one source to this input. If the
-- ChannelClass is also SINGLE_PIPELINE, this value is valid. If the
-- ChannelClass is STANDARD, this value is not valid because the channel
-- requires two sources in the input.
--
-- 'type'', 'input_type' - Undocumented member.
--
-- 'mediaConnectFlows', 'input_mediaConnectFlows' - A list of MediaConnect Flows for this input.
--
-- 'inputSourceType', 'input_inputSourceType' - Certain pull input sources can be dynamic, meaning that they can have
-- their URL\'s dynamically changes during input switch actions. Presently,
-- this functionality only works with MP4_FILE and TS_FILE inputs.
--
-- 'tags', 'input_tags' - A collection of key-value pairs.
--
-- 'roleArn', 'input_roleArn' - The Amazon Resource Name (ARN) of the role this input assumes during and
-- after creation.
newInput ::
  Input
newInput :: Input
newInput =
  Input' :: Maybe InputState
-> Maybe [Text]
-> Maybe Text
-> Maybe [InputDeviceSettings]
-> Maybe [Text]
-> Maybe [InputSource]
-> Maybe [InputDestination]
-> Maybe Text
-> Maybe [Text]
-> Maybe Text
-> Maybe InputClass
-> Maybe InputType
-> Maybe [MediaConnectFlow]
-> Maybe InputSourceType
-> Maybe (HashMap Text Text)
-> Maybe Text
-> Input
Input'
    { $sel:state:Input' :: Maybe InputState
state = Maybe InputState
forall a. Maybe a
Prelude.Nothing,
      $sel:securityGroups:Input' :: Maybe [Text]
securityGroups = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:arn:Input' :: Maybe Text
arn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:inputDevices:Input' :: Maybe [InputDeviceSettings]
inputDevices = Maybe [InputDeviceSettings]
forall a. Maybe a
Prelude.Nothing,
      $sel:inputPartnerIds:Input' :: Maybe [Text]
inputPartnerIds = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:sources:Input' :: Maybe [InputSource]
sources = Maybe [InputSource]
forall a. Maybe a
Prelude.Nothing,
      $sel:destinations:Input' :: Maybe [InputDestination]
destinations = Maybe [InputDestination]
forall a. Maybe a
Prelude.Nothing,
      $sel:name:Input' :: Maybe Text
name = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:attachedChannels:Input' :: Maybe [Text]
attachedChannels = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:id:Input' :: Maybe Text
id = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:inputClass:Input' :: Maybe InputClass
inputClass = Maybe InputClass
forall a. Maybe a
Prelude.Nothing,
      $sel:type':Input' :: Maybe InputType
type' = Maybe InputType
forall a. Maybe a
Prelude.Nothing,
      $sel:mediaConnectFlows:Input' :: Maybe [MediaConnectFlow]
mediaConnectFlows = Maybe [MediaConnectFlow]
forall a. Maybe a
Prelude.Nothing,
      $sel:inputSourceType:Input' :: Maybe InputSourceType
inputSourceType = Maybe InputSourceType
forall a. Maybe a
Prelude.Nothing,
      $sel:tags:Input' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:roleArn:Input' :: Maybe Text
roleArn = Maybe Text
forall a. Maybe a
Prelude.Nothing
    }

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

-- | A list of IDs for all the Input Security Groups attached to the input.
input_securityGroups :: Lens.Lens' Input (Prelude.Maybe [Prelude.Text])
input_securityGroups :: (Maybe [Text] -> f (Maybe [Text])) -> Input -> f Input
input_securityGroups = (Input -> Maybe [Text])
-> (Input -> Maybe [Text] -> Input)
-> Lens Input Input (Maybe [Text]) (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe [Text]
securityGroups :: Maybe [Text]
$sel:securityGroups:Input' :: Input -> Maybe [Text]
securityGroups} -> Maybe [Text]
securityGroups) (\s :: Input
s@Input' {} Maybe [Text]
a -> Input
s {$sel:securityGroups:Input' :: Maybe [Text]
securityGroups = Maybe [Text]
a} :: Input) ((Maybe [Text] -> f (Maybe [Text])) -> Input -> f Input)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> Input
-> f Input
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [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 [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The Unique ARN of the input (generated, immutable).
input_arn :: Lens.Lens' Input (Prelude.Maybe Prelude.Text)
input_arn :: (Maybe Text -> f (Maybe Text)) -> Input -> f Input
input_arn = (Input -> Maybe Text)
-> (Input -> Maybe Text -> Input)
-> Lens Input Input (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe Text
arn :: Maybe Text
$sel:arn:Input' :: Input -> Maybe Text
arn} -> Maybe Text
arn) (\s :: Input
s@Input' {} Maybe Text
a -> Input
s {$sel:arn:Input' :: Maybe Text
arn = Maybe Text
a} :: Input)

-- | Settings for the input devices.
input_inputDevices :: Lens.Lens' Input (Prelude.Maybe [InputDeviceSettings])
input_inputDevices :: (Maybe [InputDeviceSettings] -> f (Maybe [InputDeviceSettings]))
-> Input -> f Input
input_inputDevices = (Input -> Maybe [InputDeviceSettings])
-> (Input -> Maybe [InputDeviceSettings] -> Input)
-> Lens
     Input
     Input
     (Maybe [InputDeviceSettings])
     (Maybe [InputDeviceSettings])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe [InputDeviceSettings]
inputDevices :: Maybe [InputDeviceSettings]
$sel:inputDevices:Input' :: Input -> Maybe [InputDeviceSettings]
inputDevices} -> Maybe [InputDeviceSettings]
inputDevices) (\s :: Input
s@Input' {} Maybe [InputDeviceSettings]
a -> Input
s {$sel:inputDevices:Input' :: Maybe [InputDeviceSettings]
inputDevices = Maybe [InputDeviceSettings]
a} :: Input) ((Maybe [InputDeviceSettings] -> f (Maybe [InputDeviceSettings]))
 -> Input -> f Input)
-> ((Maybe [InputDeviceSettings]
     -> f (Maybe [InputDeviceSettings]))
    -> Maybe [InputDeviceSettings] -> f (Maybe [InputDeviceSettings]))
-> (Maybe [InputDeviceSettings] -> f (Maybe [InputDeviceSettings]))
-> Input
-> f Input
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [InputDeviceSettings]
  [InputDeviceSettings]
  [InputDeviceSettings]
  [InputDeviceSettings]
-> Iso
     (Maybe [InputDeviceSettings])
     (Maybe [InputDeviceSettings])
     (Maybe [InputDeviceSettings])
     (Maybe [InputDeviceSettings])
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
  [InputDeviceSettings]
  [InputDeviceSettings]
  [InputDeviceSettings]
  [InputDeviceSettings]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of IDs for all Inputs which are partners of this one.
input_inputPartnerIds :: Lens.Lens' Input (Prelude.Maybe [Prelude.Text])
input_inputPartnerIds :: (Maybe [Text] -> f (Maybe [Text])) -> Input -> f Input
input_inputPartnerIds = (Input -> Maybe [Text])
-> (Input -> Maybe [Text] -> Input)
-> Lens Input Input (Maybe [Text]) (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe [Text]
inputPartnerIds :: Maybe [Text]
$sel:inputPartnerIds:Input' :: Input -> Maybe [Text]
inputPartnerIds} -> Maybe [Text]
inputPartnerIds) (\s :: Input
s@Input' {} Maybe [Text]
a -> Input
s {$sel:inputPartnerIds:Input' :: Maybe [Text]
inputPartnerIds = Maybe [Text]
a} :: Input) ((Maybe [Text] -> f (Maybe [Text])) -> Input -> f Input)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> Input
-> f Input
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [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 [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of the sources of the input (PULL-type).
input_sources :: Lens.Lens' Input (Prelude.Maybe [InputSource])
input_sources :: (Maybe [InputSource] -> f (Maybe [InputSource]))
-> Input -> f Input
input_sources = (Input -> Maybe [InputSource])
-> (Input -> Maybe [InputSource] -> Input)
-> Lens Input Input (Maybe [InputSource]) (Maybe [InputSource])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe [InputSource]
sources :: Maybe [InputSource]
$sel:sources:Input' :: Input -> Maybe [InputSource]
sources} -> Maybe [InputSource]
sources) (\s :: Input
s@Input' {} Maybe [InputSource]
a -> Input
s {$sel:sources:Input' :: Maybe [InputSource]
sources = Maybe [InputSource]
a} :: Input) ((Maybe [InputSource] -> f (Maybe [InputSource]))
 -> Input -> f Input)
-> ((Maybe [InputSource] -> f (Maybe [InputSource]))
    -> Maybe [InputSource] -> f (Maybe [InputSource]))
-> (Maybe [InputSource] -> f (Maybe [InputSource]))
-> Input
-> f Input
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [InputSource] [InputSource] [InputSource] [InputSource]
-> Iso
     (Maybe [InputSource])
     (Maybe [InputSource])
     (Maybe [InputSource])
     (Maybe [InputSource])
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 [InputSource] [InputSource] [InputSource] [InputSource]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of the destinations of the input (PUSH-type).
input_destinations :: Lens.Lens' Input (Prelude.Maybe [InputDestination])
input_destinations :: (Maybe [InputDestination] -> f (Maybe [InputDestination]))
-> Input -> f Input
input_destinations = (Input -> Maybe [InputDestination])
-> (Input -> Maybe [InputDestination] -> Input)
-> Lens
     Input Input (Maybe [InputDestination]) (Maybe [InputDestination])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe [InputDestination]
destinations :: Maybe [InputDestination]
$sel:destinations:Input' :: Input -> Maybe [InputDestination]
destinations} -> Maybe [InputDestination]
destinations) (\s :: Input
s@Input' {} Maybe [InputDestination]
a -> Input
s {$sel:destinations:Input' :: Maybe [InputDestination]
destinations = Maybe [InputDestination]
a} :: Input) ((Maybe [InputDestination] -> f (Maybe [InputDestination]))
 -> Input -> f Input)
-> ((Maybe [InputDestination] -> f (Maybe [InputDestination]))
    -> Maybe [InputDestination] -> f (Maybe [InputDestination]))
-> (Maybe [InputDestination] -> f (Maybe [InputDestination]))
-> Input
-> f Input
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [InputDestination]
  [InputDestination]
  [InputDestination]
  [InputDestination]
-> Iso
     (Maybe [InputDestination])
     (Maybe [InputDestination])
     (Maybe [InputDestination])
     (Maybe [InputDestination])
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
  [InputDestination]
  [InputDestination]
  [InputDestination]
  [InputDestination]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The user-assigned name (This is a mutable value).
input_name :: Lens.Lens' Input (Prelude.Maybe Prelude.Text)
input_name :: (Maybe Text -> f (Maybe Text)) -> Input -> f Input
input_name = (Input -> Maybe Text)
-> (Input -> Maybe Text -> Input)
-> Lens Input Input (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe Text
name :: Maybe Text
$sel:name:Input' :: Input -> Maybe Text
name} -> Maybe Text
name) (\s :: Input
s@Input' {} Maybe Text
a -> Input
s {$sel:name:Input' :: Maybe Text
name = Maybe Text
a} :: Input)

-- | A list of channel IDs that that input is attached to (currently an input
-- can only be attached to one channel).
input_attachedChannels :: Lens.Lens' Input (Prelude.Maybe [Prelude.Text])
input_attachedChannels :: (Maybe [Text] -> f (Maybe [Text])) -> Input -> f Input
input_attachedChannels = (Input -> Maybe [Text])
-> (Input -> Maybe [Text] -> Input)
-> Lens Input Input (Maybe [Text]) (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe [Text]
attachedChannels :: Maybe [Text]
$sel:attachedChannels:Input' :: Input -> Maybe [Text]
attachedChannels} -> Maybe [Text]
attachedChannels) (\s :: Input
s@Input' {} Maybe [Text]
a -> Input
s {$sel:attachedChannels:Input' :: Maybe [Text]
attachedChannels = Maybe [Text]
a} :: Input) ((Maybe [Text] -> f (Maybe [Text])) -> Input -> f Input)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> Input
-> f Input
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [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 [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The generated ID of the input (unique for user account, immutable).
input_id :: Lens.Lens' Input (Prelude.Maybe Prelude.Text)
input_id :: (Maybe Text -> f (Maybe Text)) -> Input -> f Input
input_id = (Input -> Maybe Text)
-> (Input -> Maybe Text -> Input)
-> Lens Input Input (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe Text
id :: Maybe Text
$sel:id:Input' :: Input -> Maybe Text
id} -> Maybe Text
id) (\s :: Input
s@Input' {} Maybe Text
a -> Input
s {$sel:id:Input' :: Maybe Text
id = Maybe Text
a} :: Input)

-- | STANDARD - MediaLive expects two sources to be connected to this input.
-- If the channel is also STANDARD, both sources will be ingested. If the
-- channel is SINGLE_PIPELINE, only the first source will be ingested; the
-- second source will always be ignored, even if the first source fails.
-- SINGLE_PIPELINE - You can connect only one source to this input. If the
-- ChannelClass is also SINGLE_PIPELINE, this value is valid. If the
-- ChannelClass is STANDARD, this value is not valid because the channel
-- requires two sources in the input.
input_inputClass :: Lens.Lens' Input (Prelude.Maybe InputClass)
input_inputClass :: (Maybe InputClass -> f (Maybe InputClass)) -> Input -> f Input
input_inputClass = (Input -> Maybe InputClass)
-> (Input -> Maybe InputClass -> Input)
-> Lens Input Input (Maybe InputClass) (Maybe InputClass)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe InputClass
inputClass :: Maybe InputClass
$sel:inputClass:Input' :: Input -> Maybe InputClass
inputClass} -> Maybe InputClass
inputClass) (\s :: Input
s@Input' {} Maybe InputClass
a -> Input
s {$sel:inputClass:Input' :: Maybe InputClass
inputClass = Maybe InputClass
a} :: Input)

-- | Undocumented member.
input_type :: Lens.Lens' Input (Prelude.Maybe InputType)
input_type :: (Maybe InputType -> f (Maybe InputType)) -> Input -> f Input
input_type = (Input -> Maybe InputType)
-> (Input -> Maybe InputType -> Input)
-> Lens Input Input (Maybe InputType) (Maybe InputType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe InputType
type' :: Maybe InputType
$sel:type':Input' :: Input -> Maybe InputType
type'} -> Maybe InputType
type') (\s :: Input
s@Input' {} Maybe InputType
a -> Input
s {$sel:type':Input' :: Maybe InputType
type' = Maybe InputType
a} :: Input)

-- | A list of MediaConnect Flows for this input.
input_mediaConnectFlows :: Lens.Lens' Input (Prelude.Maybe [MediaConnectFlow])
input_mediaConnectFlows :: (Maybe [MediaConnectFlow] -> f (Maybe [MediaConnectFlow]))
-> Input -> f Input
input_mediaConnectFlows = (Input -> Maybe [MediaConnectFlow])
-> (Input -> Maybe [MediaConnectFlow] -> Input)
-> Lens
     Input Input (Maybe [MediaConnectFlow]) (Maybe [MediaConnectFlow])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe [MediaConnectFlow]
mediaConnectFlows :: Maybe [MediaConnectFlow]
$sel:mediaConnectFlows:Input' :: Input -> Maybe [MediaConnectFlow]
mediaConnectFlows} -> Maybe [MediaConnectFlow]
mediaConnectFlows) (\s :: Input
s@Input' {} Maybe [MediaConnectFlow]
a -> Input
s {$sel:mediaConnectFlows:Input' :: Maybe [MediaConnectFlow]
mediaConnectFlows = Maybe [MediaConnectFlow]
a} :: Input) ((Maybe [MediaConnectFlow] -> f (Maybe [MediaConnectFlow]))
 -> Input -> f Input)
-> ((Maybe [MediaConnectFlow] -> f (Maybe [MediaConnectFlow]))
    -> Maybe [MediaConnectFlow] -> f (Maybe [MediaConnectFlow]))
-> (Maybe [MediaConnectFlow] -> f (Maybe [MediaConnectFlow]))
-> Input
-> f Input
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [MediaConnectFlow]
  [MediaConnectFlow]
  [MediaConnectFlow]
  [MediaConnectFlow]
-> Iso
     (Maybe [MediaConnectFlow])
     (Maybe [MediaConnectFlow])
     (Maybe [MediaConnectFlow])
     (Maybe [MediaConnectFlow])
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
  [MediaConnectFlow]
  [MediaConnectFlow]
  [MediaConnectFlow]
  [MediaConnectFlow]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Certain pull input sources can be dynamic, meaning that they can have
-- their URL\'s dynamically changes during input switch actions. Presently,
-- this functionality only works with MP4_FILE and TS_FILE inputs.
input_inputSourceType :: Lens.Lens' Input (Prelude.Maybe InputSourceType)
input_inputSourceType :: (Maybe InputSourceType -> f (Maybe InputSourceType))
-> Input -> f Input
input_inputSourceType = (Input -> Maybe InputSourceType)
-> (Input -> Maybe InputSourceType -> Input)
-> Lens Input Input (Maybe InputSourceType) (Maybe InputSourceType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe InputSourceType
inputSourceType :: Maybe InputSourceType
$sel:inputSourceType:Input' :: Input -> Maybe InputSourceType
inputSourceType} -> Maybe InputSourceType
inputSourceType) (\s :: Input
s@Input' {} Maybe InputSourceType
a -> Input
s {$sel:inputSourceType:Input' :: Maybe InputSourceType
inputSourceType = Maybe InputSourceType
a} :: Input)

-- | A collection of key-value pairs.
input_tags :: Lens.Lens' Input (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
input_tags :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> Input -> f Input
input_tags = (Input -> Maybe (HashMap Text Text))
-> (Input -> Maybe (HashMap Text Text) -> Input)
-> Lens
     Input Input (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 (\Input' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:Input' :: Input -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: Input
s@Input' {} Maybe (HashMap Text Text)
a -> Input
s {$sel:tags:Input' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: Input) ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
 -> Input -> f Input)
-> ((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)))
-> Input
-> f Input
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 this input assumes during and
-- after creation.
input_roleArn :: Lens.Lens' Input (Prelude.Maybe Prelude.Text)
input_roleArn :: (Maybe Text -> f (Maybe Text)) -> Input -> f Input
input_roleArn = (Input -> Maybe Text)
-> (Input -> Maybe Text -> Input)
-> Lens Input Input (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe Text
roleArn :: Maybe Text
$sel:roleArn:Input' :: Input -> Maybe Text
roleArn} -> Maybe Text
roleArn) (\s :: Input
s@Input' {} Maybe Text
a -> Input
s {$sel:roleArn:Input' :: Maybe Text
roleArn = Maybe Text
a} :: Input)

instance Core.FromJSON Input where
  parseJSON :: Value -> Parser Input
parseJSON =
    String -> (Object -> Parser Input) -> Value -> Parser Input
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"Input"
      ( \Object
x ->
          Maybe InputState
-> Maybe [Text]
-> Maybe Text
-> Maybe [InputDeviceSettings]
-> Maybe [Text]
-> Maybe [InputSource]
-> Maybe [InputDestination]
-> Maybe Text
-> Maybe [Text]
-> Maybe Text
-> Maybe InputClass
-> Maybe InputType
-> Maybe [MediaConnectFlow]
-> Maybe InputSourceType
-> Maybe (HashMap Text Text)
-> Maybe Text
-> Input
Input'
            (Maybe InputState
 -> Maybe [Text]
 -> Maybe Text
 -> Maybe [InputDeviceSettings]
 -> Maybe [Text]
 -> Maybe [InputSource]
 -> Maybe [InputDestination]
 -> Maybe Text
 -> Maybe [Text]
 -> Maybe Text
 -> Maybe InputClass
 -> Maybe InputType
 -> Maybe [MediaConnectFlow]
 -> Maybe InputSourceType
 -> Maybe (HashMap Text Text)
 -> Maybe Text
 -> Input)
-> Parser (Maybe InputState)
-> Parser
     (Maybe [Text]
      -> Maybe Text
      -> Maybe [InputDeviceSettings]
      -> Maybe [Text]
      -> Maybe [InputSource]
      -> Maybe [InputDestination]
      -> Maybe Text
      -> Maybe [Text]
      -> Maybe Text
      -> Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe InputState)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"state")
            Parser
  (Maybe [Text]
   -> Maybe Text
   -> Maybe [InputDeviceSettings]
   -> Maybe [Text]
   -> Maybe [InputSource]
   -> Maybe [InputDestination]
   -> Maybe Text
   -> Maybe [Text]
   -> Maybe Text
   -> Maybe InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe [Text])
-> Parser
     (Maybe Text
      -> Maybe [InputDeviceSettings]
      -> Maybe [Text]
      -> Maybe [InputSource]
      -> Maybe [InputDestination]
      -> Maybe Text
      -> Maybe [Text]
      -> Maybe Text
      -> Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [Text]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"securityGroups" Parser (Maybe (Maybe [Text]))
-> Maybe [Text] -> Parser (Maybe [Text])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Text]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe Text
   -> Maybe [InputDeviceSettings]
   -> Maybe [Text]
   -> Maybe [InputSource]
   -> Maybe [InputDestination]
   -> Maybe Text
   -> Maybe [Text]
   -> Maybe Text
   -> Maybe InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe Text)
-> Parser
     (Maybe [InputDeviceSettings]
      -> Maybe [Text]
      -> Maybe [InputSource]
      -> Maybe [InputDestination]
      -> Maybe Text
      -> Maybe [Text]
      -> Maybe Text
      -> Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
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 [InputDeviceSettings]
   -> Maybe [Text]
   -> Maybe [InputSource]
   -> Maybe [InputDestination]
   -> Maybe Text
   -> Maybe [Text]
   -> Maybe Text
   -> Maybe InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe [InputDeviceSettings])
-> Parser
     (Maybe [Text]
      -> Maybe [InputSource]
      -> Maybe [InputDestination]
      -> Maybe Text
      -> Maybe [Text]
      -> Maybe Text
      -> Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [InputDeviceSettings]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"inputDevices" Parser (Maybe (Maybe [InputDeviceSettings]))
-> Maybe [InputDeviceSettings]
-> Parser (Maybe [InputDeviceSettings])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [InputDeviceSettings]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe [Text]
   -> Maybe [InputSource]
   -> Maybe [InputDestination]
   -> Maybe Text
   -> Maybe [Text]
   -> Maybe Text
   -> Maybe InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe [Text])
-> Parser
     (Maybe [InputSource]
      -> Maybe [InputDestination]
      -> Maybe Text
      -> Maybe [Text]
      -> Maybe Text
      -> Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [Text]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"inputPartnerIds"
                            Parser (Maybe (Maybe [Text]))
-> Maybe [Text] -> Parser (Maybe [Text])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Text]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe [InputSource]
   -> Maybe [InputDestination]
   -> Maybe Text
   -> Maybe [Text]
   -> Maybe Text
   -> Maybe InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe [InputSource])
-> Parser
     (Maybe [InputDestination]
      -> Maybe Text
      -> Maybe [Text]
      -> Maybe Text
      -> Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [InputSource]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"sources" Parser (Maybe (Maybe [InputSource]))
-> Maybe [InputSource] -> Parser (Maybe [InputSource])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [InputSource]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe [InputDestination]
   -> Maybe Text
   -> Maybe [Text]
   -> Maybe Text
   -> Maybe InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe [InputDestination])
-> Parser
     (Maybe Text
      -> Maybe [Text]
      -> Maybe Text
      -> Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [InputDestination]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"destinations" Parser (Maybe (Maybe [InputDestination]))
-> Maybe [InputDestination] -> Parser (Maybe [InputDestination])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [InputDestination]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe Text
   -> Maybe [Text]
   -> Maybe Text
   -> Maybe InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe Text)
-> Parser
     (Maybe [Text]
      -> Maybe Text
      -> Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
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 [Text]
   -> Maybe Text
   -> Maybe InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe [Text])
-> Parser
     (Maybe Text
      -> Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [Text]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"attachedChannels"
                            Parser (Maybe (Maybe [Text]))
-> Maybe [Text] -> Parser (Maybe [Text])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Text]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe Text
   -> Maybe InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe Text)
-> Parser
     (Maybe InputClass
      -> Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
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 InputClass
   -> Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe InputClass)
-> Parser
     (Maybe InputType
      -> Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe InputClass)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"inputClass")
            Parser
  (Maybe InputType
   -> Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe InputType)
-> Parser
     (Maybe [MediaConnectFlow]
      -> Maybe InputSourceType
      -> Maybe (HashMap Text Text)
      -> Maybe Text
      -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe InputType)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"type")
            Parser
  (Maybe [MediaConnectFlow]
   -> Maybe InputSourceType
   -> Maybe (HashMap Text Text)
   -> Maybe Text
   -> Input)
-> Parser (Maybe [MediaConnectFlow])
-> Parser
     (Maybe InputSourceType
      -> Maybe (HashMap Text Text) -> Maybe Text -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [MediaConnectFlow]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"mediaConnectFlows"
                            Parser (Maybe (Maybe [MediaConnectFlow]))
-> Maybe [MediaConnectFlow] -> Parser (Maybe [MediaConnectFlow])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [MediaConnectFlow]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe InputSourceType
   -> Maybe (HashMap Text Text) -> Maybe Text -> Input)
-> Parser (Maybe InputSourceType)
-> Parser (Maybe (HashMap Text Text) -> Maybe Text -> Input)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe InputSourceType)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"inputSourceType")
            Parser (Maybe (HashMap Text Text) -> Maybe Text -> Input)
-> Parser (Maybe (HashMap Text Text))
-> Parser (Maybe Text -> Input)
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 -> Input) -> Parser (Maybe Text) -> Parser Input
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 Input

instance Prelude.NFData Input