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

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaLive.Types.BurnInAlignment
import Amazonka.MediaLive.Types.BurnInBackgroundColor
import Amazonka.MediaLive.Types.BurnInFontColor
import Amazonka.MediaLive.Types.BurnInOutlineColor
import Amazonka.MediaLive.Types.BurnInShadowColor
import Amazonka.MediaLive.Types.BurnInTeletextGridControl
import Amazonka.MediaLive.Types.InputLocation
import qualified Amazonka.Prelude as Prelude

-- | Burn In Destination Settings
--
-- /See:/ 'newBurnInDestinationSettings' smart constructor.
data BurnInDestinationSettings = BurnInDestinationSettings'
  { -- | Specifies the opacity of the background rectangle. 255 is opaque; 0 is
    -- transparent. Leaving this parameter out is equivalent to setting it to 0
    -- (transparent). All burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Natural
backgroundOpacity :: Prelude.Maybe Prelude.Natural,
    -- | Specifies the opacity of the burned-in captions. 255 is opaque; 0 is
    -- transparent. All burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Natural
fontOpacity :: Prelude.Maybe Prelude.Natural,
    -- | Specifies the vertical offset of the shadow relative to the captions in
    -- pixels. A value of -2 would result in a shadow offset 2 pixels above the
    -- text. All burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Int
shadowYOffset :: Prelude.Maybe Prelude.Int,
    -- | Font resolution in DPI (dots per inch); default is 96 dpi. All burn-in
    -- and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Natural
fontResolution :: Prelude.Maybe Prelude.Natural,
    -- | Specifies the vertical position of the caption relative to the top of
    -- the output in pixels. A value of 10 would result in the captions
    -- starting 10 pixels from the top of the output. If no explicit yPosition
    -- is provided, the caption will be positioned towards the bottom of the
    -- output. All burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Natural
yPosition :: Prelude.Maybe Prelude.Natural,
    -- | Specifies the color of the rectangle behind the captions. All burn-in
    -- and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe BurnInBackgroundColor
backgroundColor :: Prelude.Maybe BurnInBackgroundColor,
    -- | Specifies the horizontal offset of the shadow relative to the captions
    -- in pixels. A value of -2 would result in a shadow offset 2 pixels to the
    -- left. All burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Int
shadowXOffset :: Prelude.Maybe Prelude.Int,
    -- | When set to \'auto\' fontSize will scale depending on the size of the
    -- output. Giving a positive integer will specify the exact font size in
    -- points. All burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Text
fontSize :: Prelude.Maybe Prelude.Text,
    -- | Specifies the horizontal position of the caption relative to the left
    -- side of the output in pixels. A value of 10 would result in the captions
    -- starting 10 pixels from the left of the output. If no explicit xPosition
    -- is provided, the horizontal caption position will be determined by the
    -- alignment parameter. All burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Natural
xPosition :: Prelude.Maybe Prelude.Natural,
    -- | If no explicit xPosition or yPosition is provided, setting alignment to
    -- centered will place the captions at the bottom center of the output.
    -- Similarly, setting a left alignment will align captions to the bottom
    -- left of the output. If x and y positions are given in conjunction with
    -- the alignment parameter, the font will be justified (either left or
    -- centered) relative to those coordinates. Selecting \"smart\"
    -- justification will left-justify live subtitles and center-justify
    -- pre-recorded subtitles. All burn-in and DVB-Sub font settings must
    -- match.
    BurnInDestinationSettings -> Maybe BurnInAlignment
alignment :: Prelude.Maybe BurnInAlignment,
    -- | Specifies the opacity of the shadow. 255 is opaque; 0 is transparent.
    -- Leaving this parameter out is equivalent to setting it to 0
    -- (transparent). All burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Natural
shadowOpacity :: Prelude.Maybe Prelude.Natural,
    -- | Controls whether a fixed grid size will be used to generate the output
    -- subtitles bitmap. Only applicable for Teletext inputs and
    -- DVB-Sub\/Burn-in outputs.
    BurnInDestinationSettings -> Maybe BurnInTeletextGridControl
teletextGridControl :: Prelude.Maybe BurnInTeletextGridControl,
    -- | Specifies font outline color. This option is not valid for source
    -- captions that are either 608\/embedded or teletext. These source
    -- settings are already pre-defined by the caption stream. All burn-in and
    -- DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe BurnInOutlineColor
outlineColor :: Prelude.Maybe BurnInOutlineColor,
    -- | Specifies font outline size in pixels. This option is not valid for
    -- source captions that are either 608\/embedded or teletext. These source
    -- settings are already pre-defined by the caption stream. All burn-in and
    -- DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe Natural
outlineSize :: Prelude.Maybe Prelude.Natural,
    -- | External font file used for caption burn-in. File extension must be
    -- \'ttf\' or \'tte\'. Although the user can select output fonts for many
    -- different types of input captions, embedded, STL and teletext sources
    -- use a strict grid system. Using external fonts with these caption
    -- sources could cause unexpected display of proportional fonts. All
    -- burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe InputLocation
font :: Prelude.Maybe InputLocation,
    -- | Specifies the color of the shadow cast by the captions. All burn-in and
    -- DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe BurnInShadowColor
shadowColor :: Prelude.Maybe BurnInShadowColor,
    -- | Specifies the color of the burned-in captions. This option is not valid
    -- for source captions that are STL, 608\/embedded or teletext. These
    -- source settings are already pre-defined by the caption stream. All
    -- burn-in and DVB-Sub font settings must match.
    BurnInDestinationSettings -> Maybe BurnInFontColor
fontColor :: Prelude.Maybe BurnInFontColor
  }
  deriving (BurnInDestinationSettings -> BurnInDestinationSettings -> Bool
(BurnInDestinationSettings -> BurnInDestinationSettings -> Bool)
-> (BurnInDestinationSettings -> BurnInDestinationSettings -> Bool)
-> Eq BurnInDestinationSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BurnInDestinationSettings -> BurnInDestinationSettings -> Bool
$c/= :: BurnInDestinationSettings -> BurnInDestinationSettings -> Bool
== :: BurnInDestinationSettings -> BurnInDestinationSettings -> Bool
$c== :: BurnInDestinationSettings -> BurnInDestinationSettings -> Bool
Prelude.Eq, ReadPrec [BurnInDestinationSettings]
ReadPrec BurnInDestinationSettings
Int -> ReadS BurnInDestinationSettings
ReadS [BurnInDestinationSettings]
(Int -> ReadS BurnInDestinationSettings)
-> ReadS [BurnInDestinationSettings]
-> ReadPrec BurnInDestinationSettings
-> ReadPrec [BurnInDestinationSettings]
-> Read BurnInDestinationSettings
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BurnInDestinationSettings]
$creadListPrec :: ReadPrec [BurnInDestinationSettings]
readPrec :: ReadPrec BurnInDestinationSettings
$creadPrec :: ReadPrec BurnInDestinationSettings
readList :: ReadS [BurnInDestinationSettings]
$creadList :: ReadS [BurnInDestinationSettings]
readsPrec :: Int -> ReadS BurnInDestinationSettings
$creadsPrec :: Int -> ReadS BurnInDestinationSettings
Prelude.Read, Int -> BurnInDestinationSettings -> ShowS
[BurnInDestinationSettings] -> ShowS
BurnInDestinationSettings -> String
(Int -> BurnInDestinationSettings -> ShowS)
-> (BurnInDestinationSettings -> String)
-> ([BurnInDestinationSettings] -> ShowS)
-> Show BurnInDestinationSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BurnInDestinationSettings] -> ShowS
$cshowList :: [BurnInDestinationSettings] -> ShowS
show :: BurnInDestinationSettings -> String
$cshow :: BurnInDestinationSettings -> String
showsPrec :: Int -> BurnInDestinationSettings -> ShowS
$cshowsPrec :: Int -> BurnInDestinationSettings -> ShowS
Prelude.Show, (forall x.
 BurnInDestinationSettings -> Rep BurnInDestinationSettings x)
-> (forall x.
    Rep BurnInDestinationSettings x -> BurnInDestinationSettings)
-> Generic BurnInDestinationSettings
forall x.
Rep BurnInDestinationSettings x -> BurnInDestinationSettings
forall x.
BurnInDestinationSettings -> Rep BurnInDestinationSettings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep BurnInDestinationSettings x -> BurnInDestinationSettings
$cfrom :: forall x.
BurnInDestinationSettings -> Rep BurnInDestinationSettings x
Prelude.Generic)

-- |
-- Create a value of 'BurnInDestinationSettings' 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:
--
-- 'backgroundOpacity', 'burnInDestinationSettings_backgroundOpacity' - Specifies the opacity of the background rectangle. 255 is opaque; 0 is
-- transparent. Leaving this parameter out is equivalent to setting it to 0
-- (transparent). All burn-in and DVB-Sub font settings must match.
--
-- 'fontOpacity', 'burnInDestinationSettings_fontOpacity' - Specifies the opacity of the burned-in captions. 255 is opaque; 0 is
-- transparent. All burn-in and DVB-Sub font settings must match.
--
-- 'shadowYOffset', 'burnInDestinationSettings_shadowYOffset' - Specifies the vertical offset of the shadow relative to the captions in
-- pixels. A value of -2 would result in a shadow offset 2 pixels above the
-- text. All burn-in and DVB-Sub font settings must match.
--
-- 'fontResolution', 'burnInDestinationSettings_fontResolution' - Font resolution in DPI (dots per inch); default is 96 dpi. All burn-in
-- and DVB-Sub font settings must match.
--
-- 'yPosition', 'burnInDestinationSettings_yPosition' - Specifies the vertical position of the caption relative to the top of
-- the output in pixels. A value of 10 would result in the captions
-- starting 10 pixels from the top of the output. If no explicit yPosition
-- is provided, the caption will be positioned towards the bottom of the
-- output. All burn-in and DVB-Sub font settings must match.
--
-- 'backgroundColor', 'burnInDestinationSettings_backgroundColor' - Specifies the color of the rectangle behind the captions. All burn-in
-- and DVB-Sub font settings must match.
--
-- 'shadowXOffset', 'burnInDestinationSettings_shadowXOffset' - Specifies the horizontal offset of the shadow relative to the captions
-- in pixels. A value of -2 would result in a shadow offset 2 pixels to the
-- left. All burn-in and DVB-Sub font settings must match.
--
-- 'fontSize', 'burnInDestinationSettings_fontSize' - When set to \'auto\' fontSize will scale depending on the size of the
-- output. Giving a positive integer will specify the exact font size in
-- points. All burn-in and DVB-Sub font settings must match.
--
-- 'xPosition', 'burnInDestinationSettings_xPosition' - Specifies the horizontal position of the caption relative to the left
-- side of the output in pixels. A value of 10 would result in the captions
-- starting 10 pixels from the left of the output. If no explicit xPosition
-- is provided, the horizontal caption position will be determined by the
-- alignment parameter. All burn-in and DVB-Sub font settings must match.
--
-- 'alignment', 'burnInDestinationSettings_alignment' - If no explicit xPosition or yPosition is provided, setting alignment to
-- centered will place the captions at the bottom center of the output.
-- Similarly, setting a left alignment will align captions to the bottom
-- left of the output. If x and y positions are given in conjunction with
-- the alignment parameter, the font will be justified (either left or
-- centered) relative to those coordinates. Selecting \"smart\"
-- justification will left-justify live subtitles and center-justify
-- pre-recorded subtitles. All burn-in and DVB-Sub font settings must
-- match.
--
-- 'shadowOpacity', 'burnInDestinationSettings_shadowOpacity' - Specifies the opacity of the shadow. 255 is opaque; 0 is transparent.
-- Leaving this parameter out is equivalent to setting it to 0
-- (transparent). All burn-in and DVB-Sub font settings must match.
--
-- 'teletextGridControl', 'burnInDestinationSettings_teletextGridControl' - Controls whether a fixed grid size will be used to generate the output
-- subtitles bitmap. Only applicable for Teletext inputs and
-- DVB-Sub\/Burn-in outputs.
--
-- 'outlineColor', 'burnInDestinationSettings_outlineColor' - Specifies font outline color. This option is not valid for source
-- captions that are either 608\/embedded or teletext. These source
-- settings are already pre-defined by the caption stream. All burn-in and
-- DVB-Sub font settings must match.
--
-- 'outlineSize', 'burnInDestinationSettings_outlineSize' - Specifies font outline size in pixels. This option is not valid for
-- source captions that are either 608\/embedded or teletext. These source
-- settings are already pre-defined by the caption stream. All burn-in and
-- DVB-Sub font settings must match.
--
-- 'font', 'burnInDestinationSettings_font' - External font file used for caption burn-in. File extension must be
-- \'ttf\' or \'tte\'. Although the user can select output fonts for many
-- different types of input captions, embedded, STL and teletext sources
-- use a strict grid system. Using external fonts with these caption
-- sources could cause unexpected display of proportional fonts. All
-- burn-in and DVB-Sub font settings must match.
--
-- 'shadowColor', 'burnInDestinationSettings_shadowColor' - Specifies the color of the shadow cast by the captions. All burn-in and
-- DVB-Sub font settings must match.
--
-- 'fontColor', 'burnInDestinationSettings_fontColor' - Specifies the color of the burned-in captions. This option is not valid
-- for source captions that are STL, 608\/embedded or teletext. These
-- source settings are already pre-defined by the caption stream. All
-- burn-in and DVB-Sub font settings must match.
newBurnInDestinationSettings ::
  BurnInDestinationSettings
newBurnInDestinationSettings :: BurnInDestinationSettings
newBurnInDestinationSettings =
  BurnInDestinationSettings' :: Maybe Natural
-> Maybe Natural
-> Maybe Int
-> Maybe Natural
-> Maybe Natural
-> Maybe BurnInBackgroundColor
-> Maybe Int
-> Maybe Text
-> Maybe Natural
-> Maybe BurnInAlignment
-> Maybe Natural
-> Maybe BurnInTeletextGridControl
-> Maybe BurnInOutlineColor
-> Maybe Natural
-> Maybe InputLocation
-> Maybe BurnInShadowColor
-> Maybe BurnInFontColor
-> BurnInDestinationSettings
BurnInDestinationSettings'
    { $sel:backgroundOpacity:BurnInDestinationSettings' :: Maybe Natural
backgroundOpacity =
        Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:fontOpacity:BurnInDestinationSettings' :: Maybe Natural
fontOpacity = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:shadowYOffset:BurnInDestinationSettings' :: Maybe Int
shadowYOffset = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:fontResolution:BurnInDestinationSettings' :: Maybe Natural
fontResolution = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:yPosition:BurnInDestinationSettings' :: Maybe Natural
yPosition = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:backgroundColor:BurnInDestinationSettings' :: Maybe BurnInBackgroundColor
backgroundColor = Maybe BurnInBackgroundColor
forall a. Maybe a
Prelude.Nothing,
      $sel:shadowXOffset:BurnInDestinationSettings' :: Maybe Int
shadowXOffset = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:fontSize:BurnInDestinationSettings' :: Maybe Text
fontSize = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:xPosition:BurnInDestinationSettings' :: Maybe Natural
xPosition = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:alignment:BurnInDestinationSettings' :: Maybe BurnInAlignment
alignment = Maybe BurnInAlignment
forall a. Maybe a
Prelude.Nothing,
      $sel:shadowOpacity:BurnInDestinationSettings' :: Maybe Natural
shadowOpacity = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:teletextGridControl:BurnInDestinationSettings' :: Maybe BurnInTeletextGridControl
teletextGridControl = Maybe BurnInTeletextGridControl
forall a. Maybe a
Prelude.Nothing,
      $sel:outlineColor:BurnInDestinationSettings' :: Maybe BurnInOutlineColor
outlineColor = Maybe BurnInOutlineColor
forall a. Maybe a
Prelude.Nothing,
      $sel:outlineSize:BurnInDestinationSettings' :: Maybe Natural
outlineSize = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:font:BurnInDestinationSettings' :: Maybe InputLocation
font = Maybe InputLocation
forall a. Maybe a
Prelude.Nothing,
      $sel:shadowColor:BurnInDestinationSettings' :: Maybe BurnInShadowColor
shadowColor = Maybe BurnInShadowColor
forall a. Maybe a
Prelude.Nothing,
      $sel:fontColor:BurnInDestinationSettings' :: Maybe BurnInFontColor
fontColor = Maybe BurnInFontColor
forall a. Maybe a
Prelude.Nothing
    }

-- | Specifies the opacity of the background rectangle. 255 is opaque; 0 is
-- transparent. Leaving this parameter out is equivalent to setting it to 0
-- (transparent). All burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_backgroundOpacity :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Natural)
burnInDestinationSettings_backgroundOpacity :: (Maybe Natural -> f (Maybe Natural))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_backgroundOpacity = (BurnInDestinationSettings -> Maybe Natural)
-> (BurnInDestinationSettings
    -> Maybe Natural -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Natural
backgroundOpacity :: Maybe Natural
$sel:backgroundOpacity:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
backgroundOpacity} -> Maybe Natural
backgroundOpacity) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Natural
a -> BurnInDestinationSettings
s {$sel:backgroundOpacity:BurnInDestinationSettings' :: Maybe Natural
backgroundOpacity = Maybe Natural
a} :: BurnInDestinationSettings)

-- | Specifies the opacity of the burned-in captions. 255 is opaque; 0 is
-- transparent. All burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_fontOpacity :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Natural)
burnInDestinationSettings_fontOpacity :: (Maybe Natural -> f (Maybe Natural))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_fontOpacity = (BurnInDestinationSettings -> Maybe Natural)
-> (BurnInDestinationSettings
    -> Maybe Natural -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Natural
fontOpacity :: Maybe Natural
$sel:fontOpacity:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
fontOpacity} -> Maybe Natural
fontOpacity) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Natural
a -> BurnInDestinationSettings
s {$sel:fontOpacity:BurnInDestinationSettings' :: Maybe Natural
fontOpacity = Maybe Natural
a} :: BurnInDestinationSettings)

-- | Specifies the vertical offset of the shadow relative to the captions in
-- pixels. A value of -2 would result in a shadow offset 2 pixels above the
-- text. All burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_shadowYOffset :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Int)
burnInDestinationSettings_shadowYOffset :: (Maybe Int -> f (Maybe Int))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_shadowYOffset = (BurnInDestinationSettings -> Maybe Int)
-> (BurnInDestinationSettings
    -> Maybe Int -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Int)
     (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Int
shadowYOffset :: Maybe Int
$sel:shadowYOffset:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Int
shadowYOffset} -> Maybe Int
shadowYOffset) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Int
a -> BurnInDestinationSettings
s {$sel:shadowYOffset:BurnInDestinationSettings' :: Maybe Int
shadowYOffset = Maybe Int
a} :: BurnInDestinationSettings)

-- | Font resolution in DPI (dots per inch); default is 96 dpi. All burn-in
-- and DVB-Sub font settings must match.
burnInDestinationSettings_fontResolution :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Natural)
burnInDestinationSettings_fontResolution :: (Maybe Natural -> f (Maybe Natural))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_fontResolution = (BurnInDestinationSettings -> Maybe Natural)
-> (BurnInDestinationSettings
    -> Maybe Natural -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Natural
fontResolution :: Maybe Natural
$sel:fontResolution:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
fontResolution} -> Maybe Natural
fontResolution) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Natural
a -> BurnInDestinationSettings
s {$sel:fontResolution:BurnInDestinationSettings' :: Maybe Natural
fontResolution = Maybe Natural
a} :: BurnInDestinationSettings)

-- | Specifies the vertical position of the caption relative to the top of
-- the output in pixels. A value of 10 would result in the captions
-- starting 10 pixels from the top of the output. If no explicit yPosition
-- is provided, the caption will be positioned towards the bottom of the
-- output. All burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_yPosition :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Natural)
burnInDestinationSettings_yPosition :: (Maybe Natural -> f (Maybe Natural))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_yPosition = (BurnInDestinationSettings -> Maybe Natural)
-> (BurnInDestinationSettings
    -> Maybe Natural -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Natural
yPosition :: Maybe Natural
$sel:yPosition:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
yPosition} -> Maybe Natural
yPosition) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Natural
a -> BurnInDestinationSettings
s {$sel:yPosition:BurnInDestinationSettings' :: Maybe Natural
yPosition = Maybe Natural
a} :: BurnInDestinationSettings)

-- | Specifies the color of the rectangle behind the captions. All burn-in
-- and DVB-Sub font settings must match.
burnInDestinationSettings_backgroundColor :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe BurnInBackgroundColor)
burnInDestinationSettings_backgroundColor :: (Maybe BurnInBackgroundColor -> f (Maybe BurnInBackgroundColor))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_backgroundColor = (BurnInDestinationSettings -> Maybe BurnInBackgroundColor)
-> (BurnInDestinationSettings
    -> Maybe BurnInBackgroundColor -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe BurnInBackgroundColor)
     (Maybe BurnInBackgroundColor)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe BurnInBackgroundColor
backgroundColor :: Maybe BurnInBackgroundColor
$sel:backgroundColor:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInBackgroundColor
backgroundColor} -> Maybe BurnInBackgroundColor
backgroundColor) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe BurnInBackgroundColor
a -> BurnInDestinationSettings
s {$sel:backgroundColor:BurnInDestinationSettings' :: Maybe BurnInBackgroundColor
backgroundColor = Maybe BurnInBackgroundColor
a} :: BurnInDestinationSettings)

-- | Specifies the horizontal offset of the shadow relative to the captions
-- in pixels. A value of -2 would result in a shadow offset 2 pixels to the
-- left. All burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_shadowXOffset :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Int)
burnInDestinationSettings_shadowXOffset :: (Maybe Int -> f (Maybe Int))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_shadowXOffset = (BurnInDestinationSettings -> Maybe Int)
-> (BurnInDestinationSettings
    -> Maybe Int -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Int)
     (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Int
shadowXOffset :: Maybe Int
$sel:shadowXOffset:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Int
shadowXOffset} -> Maybe Int
shadowXOffset) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Int
a -> BurnInDestinationSettings
s {$sel:shadowXOffset:BurnInDestinationSettings' :: Maybe Int
shadowXOffset = Maybe Int
a} :: BurnInDestinationSettings)

-- | When set to \'auto\' fontSize will scale depending on the size of the
-- output. Giving a positive integer will specify the exact font size in
-- points. All burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_fontSize :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Text)
burnInDestinationSettings_fontSize :: (Maybe Text -> f (Maybe Text))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_fontSize = (BurnInDestinationSettings -> Maybe Text)
-> (BurnInDestinationSettings
    -> Maybe Text -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Text
fontSize :: Maybe Text
$sel:fontSize:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Text
fontSize} -> Maybe Text
fontSize) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Text
a -> BurnInDestinationSettings
s {$sel:fontSize:BurnInDestinationSettings' :: Maybe Text
fontSize = Maybe Text
a} :: BurnInDestinationSettings)

-- | Specifies the horizontal position of the caption relative to the left
-- side of the output in pixels. A value of 10 would result in the captions
-- starting 10 pixels from the left of the output. If no explicit xPosition
-- is provided, the horizontal caption position will be determined by the
-- alignment parameter. All burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_xPosition :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Natural)
burnInDestinationSettings_xPosition :: (Maybe Natural -> f (Maybe Natural))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_xPosition = (BurnInDestinationSettings -> Maybe Natural)
-> (BurnInDestinationSettings
    -> Maybe Natural -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Natural
xPosition :: Maybe Natural
$sel:xPosition:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
xPosition} -> Maybe Natural
xPosition) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Natural
a -> BurnInDestinationSettings
s {$sel:xPosition:BurnInDestinationSettings' :: Maybe Natural
xPosition = Maybe Natural
a} :: BurnInDestinationSettings)

-- | If no explicit xPosition or yPosition is provided, setting alignment to
-- centered will place the captions at the bottom center of the output.
-- Similarly, setting a left alignment will align captions to the bottom
-- left of the output. If x and y positions are given in conjunction with
-- the alignment parameter, the font will be justified (either left or
-- centered) relative to those coordinates. Selecting \"smart\"
-- justification will left-justify live subtitles and center-justify
-- pre-recorded subtitles. All burn-in and DVB-Sub font settings must
-- match.
burnInDestinationSettings_alignment :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe BurnInAlignment)
burnInDestinationSettings_alignment :: (Maybe BurnInAlignment -> f (Maybe BurnInAlignment))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_alignment = (BurnInDestinationSettings -> Maybe BurnInAlignment)
-> (BurnInDestinationSettings
    -> Maybe BurnInAlignment -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe BurnInAlignment)
     (Maybe BurnInAlignment)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe BurnInAlignment
alignment :: Maybe BurnInAlignment
$sel:alignment:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInAlignment
alignment} -> Maybe BurnInAlignment
alignment) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe BurnInAlignment
a -> BurnInDestinationSettings
s {$sel:alignment:BurnInDestinationSettings' :: Maybe BurnInAlignment
alignment = Maybe BurnInAlignment
a} :: BurnInDestinationSettings)

-- | Specifies the opacity of the shadow. 255 is opaque; 0 is transparent.
-- Leaving this parameter out is equivalent to setting it to 0
-- (transparent). All burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_shadowOpacity :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Natural)
burnInDestinationSettings_shadowOpacity :: (Maybe Natural -> f (Maybe Natural))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_shadowOpacity = (BurnInDestinationSettings -> Maybe Natural)
-> (BurnInDestinationSettings
    -> Maybe Natural -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Natural
shadowOpacity :: Maybe Natural
$sel:shadowOpacity:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
shadowOpacity} -> Maybe Natural
shadowOpacity) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Natural
a -> BurnInDestinationSettings
s {$sel:shadowOpacity:BurnInDestinationSettings' :: Maybe Natural
shadowOpacity = Maybe Natural
a} :: BurnInDestinationSettings)

-- | Controls whether a fixed grid size will be used to generate the output
-- subtitles bitmap. Only applicable for Teletext inputs and
-- DVB-Sub\/Burn-in outputs.
burnInDestinationSettings_teletextGridControl :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe BurnInTeletextGridControl)
burnInDestinationSettings_teletextGridControl :: (Maybe BurnInTeletextGridControl
 -> f (Maybe BurnInTeletextGridControl))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_teletextGridControl = (BurnInDestinationSettings -> Maybe BurnInTeletextGridControl)
-> (BurnInDestinationSettings
    -> Maybe BurnInTeletextGridControl -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe BurnInTeletextGridControl)
     (Maybe BurnInTeletextGridControl)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe BurnInTeletextGridControl
teletextGridControl :: Maybe BurnInTeletextGridControl
$sel:teletextGridControl:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInTeletextGridControl
teletextGridControl} -> Maybe BurnInTeletextGridControl
teletextGridControl) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe BurnInTeletextGridControl
a -> BurnInDestinationSettings
s {$sel:teletextGridControl:BurnInDestinationSettings' :: Maybe BurnInTeletextGridControl
teletextGridControl = Maybe BurnInTeletextGridControl
a} :: BurnInDestinationSettings)

-- | Specifies font outline color. This option is not valid for source
-- captions that are either 608\/embedded or teletext. These source
-- settings are already pre-defined by the caption stream. All burn-in and
-- DVB-Sub font settings must match.
burnInDestinationSettings_outlineColor :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe BurnInOutlineColor)
burnInDestinationSettings_outlineColor :: (Maybe BurnInOutlineColor -> f (Maybe BurnInOutlineColor))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_outlineColor = (BurnInDestinationSettings -> Maybe BurnInOutlineColor)
-> (BurnInDestinationSettings
    -> Maybe BurnInOutlineColor -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe BurnInOutlineColor)
     (Maybe BurnInOutlineColor)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe BurnInOutlineColor
outlineColor :: Maybe BurnInOutlineColor
$sel:outlineColor:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInOutlineColor
outlineColor} -> Maybe BurnInOutlineColor
outlineColor) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe BurnInOutlineColor
a -> BurnInDestinationSettings
s {$sel:outlineColor:BurnInDestinationSettings' :: Maybe BurnInOutlineColor
outlineColor = Maybe BurnInOutlineColor
a} :: BurnInDestinationSettings)

-- | Specifies font outline size in pixels. This option is not valid for
-- source captions that are either 608\/embedded or teletext. These source
-- settings are already pre-defined by the caption stream. All burn-in and
-- DVB-Sub font settings must match.
burnInDestinationSettings_outlineSize :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe Prelude.Natural)
burnInDestinationSettings_outlineSize :: (Maybe Natural -> f (Maybe Natural))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_outlineSize = (BurnInDestinationSettings -> Maybe Natural)
-> (BurnInDestinationSettings
    -> Maybe Natural -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe Natural
outlineSize :: Maybe Natural
$sel:outlineSize:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
outlineSize} -> Maybe Natural
outlineSize) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe Natural
a -> BurnInDestinationSettings
s {$sel:outlineSize:BurnInDestinationSettings' :: Maybe Natural
outlineSize = Maybe Natural
a} :: BurnInDestinationSettings)

-- | External font file used for caption burn-in. File extension must be
-- \'ttf\' or \'tte\'. Although the user can select output fonts for many
-- different types of input captions, embedded, STL and teletext sources
-- use a strict grid system. Using external fonts with these caption
-- sources could cause unexpected display of proportional fonts. All
-- burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_font :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe InputLocation)
burnInDestinationSettings_font :: (Maybe InputLocation -> f (Maybe InputLocation))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_font = (BurnInDestinationSettings -> Maybe InputLocation)
-> (BurnInDestinationSettings
    -> Maybe InputLocation -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe InputLocation)
     (Maybe InputLocation)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe InputLocation
font :: Maybe InputLocation
$sel:font:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe InputLocation
font} -> Maybe InputLocation
font) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe InputLocation
a -> BurnInDestinationSettings
s {$sel:font:BurnInDestinationSettings' :: Maybe InputLocation
font = Maybe InputLocation
a} :: BurnInDestinationSettings)

-- | Specifies the color of the shadow cast by the captions. All burn-in and
-- DVB-Sub font settings must match.
burnInDestinationSettings_shadowColor :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe BurnInShadowColor)
burnInDestinationSettings_shadowColor :: (Maybe BurnInShadowColor -> f (Maybe BurnInShadowColor))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_shadowColor = (BurnInDestinationSettings -> Maybe BurnInShadowColor)
-> (BurnInDestinationSettings
    -> Maybe BurnInShadowColor -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe BurnInShadowColor)
     (Maybe BurnInShadowColor)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe BurnInShadowColor
shadowColor :: Maybe BurnInShadowColor
$sel:shadowColor:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInShadowColor
shadowColor} -> Maybe BurnInShadowColor
shadowColor) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe BurnInShadowColor
a -> BurnInDestinationSettings
s {$sel:shadowColor:BurnInDestinationSettings' :: Maybe BurnInShadowColor
shadowColor = Maybe BurnInShadowColor
a} :: BurnInDestinationSettings)

-- | Specifies the color of the burned-in captions. This option is not valid
-- for source captions that are STL, 608\/embedded or teletext. These
-- source settings are already pre-defined by the caption stream. All
-- burn-in and DVB-Sub font settings must match.
burnInDestinationSettings_fontColor :: Lens.Lens' BurnInDestinationSettings (Prelude.Maybe BurnInFontColor)
burnInDestinationSettings_fontColor :: (Maybe BurnInFontColor -> f (Maybe BurnInFontColor))
-> BurnInDestinationSettings -> f BurnInDestinationSettings
burnInDestinationSettings_fontColor = (BurnInDestinationSettings -> Maybe BurnInFontColor)
-> (BurnInDestinationSettings
    -> Maybe BurnInFontColor -> BurnInDestinationSettings)
-> Lens
     BurnInDestinationSettings
     BurnInDestinationSettings
     (Maybe BurnInFontColor)
     (Maybe BurnInFontColor)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurnInDestinationSettings' {Maybe BurnInFontColor
fontColor :: Maybe BurnInFontColor
$sel:fontColor:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInFontColor
fontColor} -> Maybe BurnInFontColor
fontColor) (\s :: BurnInDestinationSettings
s@BurnInDestinationSettings' {} Maybe BurnInFontColor
a -> BurnInDestinationSettings
s {$sel:fontColor:BurnInDestinationSettings' :: Maybe BurnInFontColor
fontColor = Maybe BurnInFontColor
a} :: BurnInDestinationSettings)

instance Core.FromJSON BurnInDestinationSettings where
  parseJSON :: Value -> Parser BurnInDestinationSettings
parseJSON =
    String
-> (Object -> Parser BurnInDestinationSettings)
-> Value
-> Parser BurnInDestinationSettings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"BurnInDestinationSettings"
      ( \Object
x ->
          Maybe Natural
-> Maybe Natural
-> Maybe Int
-> Maybe Natural
-> Maybe Natural
-> Maybe BurnInBackgroundColor
-> Maybe Int
-> Maybe Text
-> Maybe Natural
-> Maybe BurnInAlignment
-> Maybe Natural
-> Maybe BurnInTeletextGridControl
-> Maybe BurnInOutlineColor
-> Maybe Natural
-> Maybe InputLocation
-> Maybe BurnInShadowColor
-> Maybe BurnInFontColor
-> BurnInDestinationSettings
BurnInDestinationSettings'
            (Maybe Natural
 -> Maybe Natural
 -> Maybe Int
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe BurnInBackgroundColor
 -> Maybe Int
 -> Maybe Text
 -> Maybe Natural
 -> Maybe BurnInAlignment
 -> Maybe Natural
 -> Maybe BurnInTeletextGridControl
 -> Maybe BurnInOutlineColor
 -> Maybe Natural
 -> Maybe InputLocation
 -> Maybe BurnInShadowColor
 -> Maybe BurnInFontColor
 -> BurnInDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurnInBackgroundColor
      -> Maybe Int
      -> Maybe Text
      -> Maybe Natural
      -> Maybe BurnInAlignment
      -> Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"backgroundOpacity")
            Parser
  (Maybe Natural
   -> Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurnInBackgroundColor
   -> Maybe Int
   -> Maybe Text
   -> Maybe Natural
   -> Maybe BurnInAlignment
   -> Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurnInBackgroundColor
      -> Maybe Int
      -> Maybe Text
      -> Maybe Natural
      -> Maybe BurnInAlignment
      -> Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"fontOpacity")
            Parser
  (Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurnInBackgroundColor
   -> Maybe Int
   -> Maybe Text
   -> Maybe Natural
   -> Maybe BurnInAlignment
   -> Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe Int)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe BurnInBackgroundColor
      -> Maybe Int
      -> Maybe Text
      -> Maybe Natural
      -> Maybe BurnInAlignment
      -> Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
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
"shadowYOffset")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe BurnInBackgroundColor
   -> Maybe Int
   -> Maybe Text
   -> Maybe Natural
   -> Maybe BurnInAlignment
   -> Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe BurnInBackgroundColor
      -> Maybe Int
      -> Maybe Text
      -> Maybe Natural
      -> Maybe BurnInAlignment
      -> Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"fontResolution")
            Parser
  (Maybe Natural
   -> Maybe BurnInBackgroundColor
   -> Maybe Int
   -> Maybe Text
   -> Maybe Natural
   -> Maybe BurnInAlignment
   -> Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe BurnInBackgroundColor
      -> Maybe Int
      -> Maybe Text
      -> Maybe Natural
      -> Maybe BurnInAlignment
      -> Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"yPosition")
            Parser
  (Maybe BurnInBackgroundColor
   -> Maybe Int
   -> Maybe Text
   -> Maybe Natural
   -> Maybe BurnInAlignment
   -> Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe BurnInBackgroundColor)
-> Parser
     (Maybe Int
      -> Maybe Text
      -> Maybe Natural
      -> Maybe BurnInAlignment
      -> Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurnInBackgroundColor)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"backgroundColor")
            Parser
  (Maybe Int
   -> Maybe Text
   -> Maybe Natural
   -> Maybe BurnInAlignment
   -> Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe Int)
-> Parser
     (Maybe Text
      -> Maybe Natural
      -> Maybe BurnInAlignment
      -> Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
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
"shadowXOffset")
            Parser
  (Maybe Text
   -> Maybe Natural
   -> Maybe BurnInAlignment
   -> Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe Text)
-> Parser
     (Maybe Natural
      -> Maybe BurnInAlignment
      -> Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
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
"fontSize")
            Parser
  (Maybe Natural
   -> Maybe BurnInAlignment
   -> Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe BurnInAlignment
      -> Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"xPosition")
            Parser
  (Maybe BurnInAlignment
   -> Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe BurnInAlignment)
-> Parser
     (Maybe Natural
      -> Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurnInAlignment)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"alignment")
            Parser
  (Maybe Natural
   -> Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe BurnInTeletextGridControl
      -> Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"shadowOpacity")
            Parser
  (Maybe BurnInTeletextGridControl
   -> Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe BurnInTeletextGridControl)
-> Parser
     (Maybe BurnInOutlineColor
      -> Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurnInTeletextGridControl)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"teletextGridControl")
            Parser
  (Maybe BurnInOutlineColor
   -> Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe BurnInOutlineColor)
-> Parser
     (Maybe Natural
      -> Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurnInOutlineColor)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"outlineColor")
            Parser
  (Maybe Natural
   -> Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe InputLocation
      -> Maybe BurnInShadowColor
      -> Maybe BurnInFontColor
      -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"outlineSize")
            Parser
  (Maybe InputLocation
   -> Maybe BurnInShadowColor
   -> Maybe BurnInFontColor
   -> BurnInDestinationSettings)
-> Parser (Maybe InputLocation)
-> Parser
     (Maybe BurnInShadowColor
      -> Maybe BurnInFontColor -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe InputLocation)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"font")
            Parser
  (Maybe BurnInShadowColor
   -> Maybe BurnInFontColor -> BurnInDestinationSettings)
-> Parser (Maybe BurnInShadowColor)
-> Parser (Maybe BurnInFontColor -> BurnInDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurnInShadowColor)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"shadowColor")
            Parser (Maybe BurnInFontColor -> BurnInDestinationSettings)
-> Parser (Maybe BurnInFontColor)
-> Parser BurnInDestinationSettings
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurnInFontColor)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"fontColor")
      )

instance Prelude.Hashable BurnInDestinationSettings

instance Prelude.NFData BurnInDestinationSettings

instance Core.ToJSON BurnInDestinationSettings where
  toJSON :: BurnInDestinationSettings -> Value
toJSON BurnInDestinationSettings' {Maybe Int
Maybe Natural
Maybe Text
Maybe BurnInAlignment
Maybe BurnInBackgroundColor
Maybe BurnInFontColor
Maybe BurnInOutlineColor
Maybe BurnInShadowColor
Maybe BurnInTeletextGridControl
Maybe InputLocation
fontColor :: Maybe BurnInFontColor
shadowColor :: Maybe BurnInShadowColor
font :: Maybe InputLocation
outlineSize :: Maybe Natural
outlineColor :: Maybe BurnInOutlineColor
teletextGridControl :: Maybe BurnInTeletextGridControl
shadowOpacity :: Maybe Natural
alignment :: Maybe BurnInAlignment
xPosition :: Maybe Natural
fontSize :: Maybe Text
shadowXOffset :: Maybe Int
backgroundColor :: Maybe BurnInBackgroundColor
yPosition :: Maybe Natural
fontResolution :: Maybe Natural
shadowYOffset :: Maybe Int
fontOpacity :: Maybe Natural
backgroundOpacity :: Maybe Natural
$sel:fontColor:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInFontColor
$sel:shadowColor:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInShadowColor
$sel:font:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe InputLocation
$sel:outlineSize:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
$sel:outlineColor:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInOutlineColor
$sel:teletextGridControl:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInTeletextGridControl
$sel:shadowOpacity:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
$sel:alignment:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInAlignment
$sel:xPosition:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
$sel:fontSize:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Text
$sel:shadowXOffset:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Int
$sel:backgroundColor:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe BurnInBackgroundColor
$sel:yPosition:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
$sel:fontResolution:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
$sel:shadowYOffset:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Int
$sel:fontOpacity:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
$sel:backgroundOpacity:BurnInDestinationSettings' :: BurnInDestinationSettings -> Maybe Natural
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"backgroundOpacity" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
backgroundOpacity,
            (Text
"fontOpacity" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
fontOpacity,
            (Text
"shadowYOffset" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
shadowYOffset,
            (Text
"fontResolution" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
fontResolution,
            (Text
"yPosition" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
yPosition,
            (Text
"backgroundColor" Text -> BurnInBackgroundColor -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (BurnInBackgroundColor -> Pair)
-> Maybe BurnInBackgroundColor -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurnInBackgroundColor
backgroundColor,
            (Text
"shadowXOffset" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
shadowXOffset,
            (Text
"fontSize" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
fontSize,
            (Text
"xPosition" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
xPosition,
            (Text
"alignment" Text -> BurnInAlignment -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BurnInAlignment -> Pair) -> Maybe BurnInAlignment -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurnInAlignment
alignment,
            (Text
"shadowOpacity" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
shadowOpacity,
            (Text
"teletextGridControl" Text -> BurnInTeletextGridControl -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (BurnInTeletextGridControl -> Pair)
-> Maybe BurnInTeletextGridControl -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurnInTeletextGridControl
teletextGridControl,
            (Text
"outlineColor" Text -> BurnInOutlineColor -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BurnInOutlineColor -> Pair)
-> Maybe BurnInOutlineColor -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurnInOutlineColor
outlineColor,
            (Text
"outlineSize" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
outlineSize,
            (Text
"font" Text -> InputLocation -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (InputLocation -> Pair) -> Maybe InputLocation -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe InputLocation
font,
            (Text
"shadowColor" Text -> BurnInShadowColor -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BurnInShadowColor -> Pair)
-> Maybe BurnInShadowColor -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurnInShadowColor
shadowColor,
            (Text
"fontColor" Text -> BurnInFontColor -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BurnInFontColor -> Pair) -> Maybe BurnInFontColor -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurnInFontColor
fontColor
          ]
      )