{-# 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.MediaConvert.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.MediaConvert.Types.BurninDestinationSettings where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaConvert.Types.BurnInSubtitleStylePassthrough
import Amazonka.MediaConvert.Types.BurninSubtitleAlignment
import Amazonka.MediaConvert.Types.BurninSubtitleApplyFontColor
import Amazonka.MediaConvert.Types.BurninSubtitleBackgroundColor
import Amazonka.MediaConvert.Types.BurninSubtitleFallbackFont
import Amazonka.MediaConvert.Types.BurninSubtitleFontColor
import Amazonka.MediaConvert.Types.BurninSubtitleOutlineColor
import Amazonka.MediaConvert.Types.BurninSubtitleShadowColor
import Amazonka.MediaConvert.Types.BurninSubtitleTeletextSpacing
import Amazonka.MediaConvert.Types.FontScript
import qualified Amazonka.Prelude as Prelude

-- | Burn-in is a captions delivery method, rather than a captions format.
-- Burn-in writes the captions directly on your video frames, replacing
-- pixels of video content with the captions. Set up burn-in captions in
-- the same output as your video. For more information, see
-- https:\/\/docs.aws.amazon.com\/mediaconvert\/latest\/ug\/burn-in-output-captions.html.
-- When you work directly in your JSON job specification, include this
-- object and any required children when you set destinationType to
-- BURN_IN.
--
-- /See:/ 'newBurninDestinationSettings' smart constructor.
data BurninDestinationSettings = BurninDestinationSettings'
  { -- | Specify the opacity of the background rectangle. Enter a value from 0 to
    -- 255, where 0 is transparent and 255 is opaque. If Style passthrough
    -- (StylePassthrough) is set to enabled, leave blank to pass through the
    -- background style information in your input captions to your output
    -- captions. If Style passthrough is set to disabled, leave blank to use a
    -- value of 0 and remove all backgrounds from your output captions.
    BurninDestinationSettings -> Maybe Natural
backgroundOpacity :: Prelude.Maybe Prelude.Natural,
    -- | Specify the font that you want the service to use for your burn in
    -- captions when your input captions specify a font that MediaConvert
    -- doesn\'t support. When you set Fallback font (FallbackFont) to best
    -- match (BEST_MATCH), or leave blank, MediaConvert uses a supported font
    -- that most closely matches the font that your input captions specify.
    -- When there are multiple unsupported fonts in your input captions,
    -- MediaConvert matches each font with the supported font that matches
    -- best. When you explicitly choose a replacement font, MediaConvert uses
    -- that font to replace all unsupported fonts from your input.
    BurninDestinationSettings -> Maybe BurninSubtitleFallbackFont
fallbackFont :: Prelude.Maybe BurninSubtitleFallbackFont,
    -- | Specify the opacity of the burned-in captions. 255 is opaque; 0 is
    -- transparent.
    BurninDestinationSettings -> Maybe Natural
fontOpacity :: Prelude.Maybe Prelude.Natural,
    -- | Specify 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. Leave Shadow y-offset (ShadowYOffset) blank and set Style
    -- passthrough (StylePassthrough) to enabled to use the shadow y-offset
    -- data from your input captions, if present.
    BurninDestinationSettings -> Maybe Int
shadowYOffset :: Prelude.Maybe Prelude.Int,
    -- | Specify the Font resolution (FontResolution) in DPI (dots per inch).
    BurninDestinationSettings -> Maybe Natural
fontResolution :: Prelude.Maybe Prelude.Natural,
    -- | Specify the vertical position (YPosition) of the captions, 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
    -- y_position is provided, the caption will be positioned towards the
    -- bottom of the output.
    BurninDestinationSettings -> Maybe Natural
yPosition :: Prelude.Maybe Prelude.Natural,
    -- | Specify the color of the rectangle behind the captions. Leave background
    -- color (BackgroundColor) blank and set Style passthrough
    -- (StylePassthrough) to enabled to use the background color data from your
    -- input captions, if present. Within your job settings, all of your
    -- DVB-Sub settings must be identical.
    BurninDestinationSettings -> Maybe BurninSubtitleBackgroundColor
backgroundColor :: Prelude.Maybe BurninSubtitleBackgroundColor,
    -- | Specify 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.
    BurninDestinationSettings -> Maybe Int
shadowXOffset :: Prelude.Maybe Prelude.Int,
    -- | Specify the Font size (FontSize) in pixels. Must be a positive integer.
    -- Set to 0, or leave blank, for automatic font size.
    BurninDestinationSettings -> Maybe Natural
fontSize :: Prelude.Maybe Prelude.Natural,
    -- | Specify the horizontal position (XPosition) of the captions, 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
    -- x_position is provided, the horizontal caption position will be
    -- determined by the alignment parameter.
    BurninDestinationSettings -> Maybe Natural
xPosition :: Prelude.Maybe Prelude.Natural,
    -- | Specify whether the text spacing (TeletextSpacing) in your captions is
    -- set by the captions grid, or varies depending on letter width. Choose
    -- fixed grid (FIXED_GRID) to conform to the spacing specified in the
    -- captions file more accurately. Choose proportional (PROPORTIONAL) to
    -- make the text easier to read for closed captions.
    BurninDestinationSettings -> Maybe BurninSubtitleTeletextSpacing
teletextSpacing :: Prelude.Maybe BurninSubtitleTeletextSpacing,
    -- | Set Font script (FontScript) to Automatically determined (AUTOMATIC), or
    -- leave blank, to automatically determine the font script in your input
    -- captions. Otherwise, set to Simplified Chinese (HANS) or Traditional
    -- Chinese (HANT) if your input font script uses Simplified or Traditional
    -- Chinese.
    BurninDestinationSettings -> Maybe FontScript
fontScript :: Prelude.Maybe FontScript,
    -- | Specify the alignment of your captions. If no explicit x_position is
    -- provided, setting alignment to centered will placethe captions at the
    -- bottom center of the output. Similarly, setting a left alignment
    -- willalign 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.
    BurninDestinationSettings -> Maybe BurninSubtitleAlignment
alignment :: Prelude.Maybe BurninSubtitleAlignment,
    -- | Specify the opacity of the shadow. Enter a value from 0 to 255, where 0
    -- is transparent and 255 is opaque. If Style passthrough
    -- (StylePassthrough) is set to Enabled, leave Shadow opacity
    -- (ShadowOpacity) blank to pass through the shadow style information in
    -- your input captions to your output captions. If Style passthrough is set
    -- to disabled, leave blank to use a value of 0 and remove all shadows from
    -- your output captions.
    BurninDestinationSettings -> Maybe Natural
shadowOpacity :: Prelude.Maybe Prelude.Natural,
    -- | Ignore this setting unless Style passthrough (StylePassthrough) is set
    -- to Enabled and Font color (FontColor) set to Black, Yellow, Red, Green,
    -- Blue, or Hex. Use Apply font color (ApplyFontColor) for additional font
    -- color controls. When you choose White text only (WHITE_TEXT_ONLY), or
    -- leave blank, your font color setting only applies to white text in your
    -- input captions. For example, if your font color setting is Yellow, and
    -- your input captions have red and white text, your output captions will
    -- have red and yellow text. When you choose ALL_TEXT, your font color
    -- setting applies to all of your output captions text.
    BurninDestinationSettings -> Maybe BurninSubtitleApplyFontColor
applyFontColor :: Prelude.Maybe BurninSubtitleApplyFontColor,
    -- | Set Style passthrough (StylePassthrough) to ENABLED to use the available
    -- style, color, and position information from your input captions.
    -- MediaConvert uses default settings for any missing style and position
    -- information in your input captions. Set Style passthrough to DISABLED,
    -- or leave blank, to ignore the style and position information from your
    -- input captions and use default settings: white text with black
    -- outlining, bottom-center positioning, and automatic sizing. Whether you
    -- set Style passthrough to enabled or not, you can also choose to manually
    -- override any of the individual style and position settings.
    BurninDestinationSettings -> Maybe BurnInSubtitleStylePassthrough
stylePassthrough :: Prelude.Maybe BurnInSubtitleStylePassthrough,
    -- | Specify font outline color. Leave Outline color (OutlineColor) blank and
    -- set Style passthrough (StylePassthrough) to enabled to use the font
    -- outline color data from your input captions, if present.
    BurninDestinationSettings -> Maybe BurninSubtitleOutlineColor
outlineColor :: Prelude.Maybe BurninSubtitleOutlineColor,
    -- | Specify the Outline size (OutlineSize) of the caption text, in pixels.
    -- Leave Outline size blank and set Style passthrough (StylePassthrough) to
    -- enabled to use the outline size data from your input captions, if
    -- present.
    BurninDestinationSettings -> Maybe Natural
outlineSize :: Prelude.Maybe Prelude.Natural,
    -- | Specify the color of the shadow cast by the captions. Leave Shadow color
    -- (ShadowColor) blank and set Style passthrough (StylePassthrough) to
    -- enabled to use the shadow color data from your input captions, if
    -- present.
    BurninDestinationSettings -> Maybe BurninSubtitleShadowColor
shadowColor :: Prelude.Maybe BurninSubtitleShadowColor,
    -- | Ignore this setting unless your Font color is set to Hex. Enter either
    -- six or eight hexidecimal digits, representing red, green, and blue, with
    -- two optional extra digits for alpha. For example a value of 1122AABB is
    -- a red value of 0x11, a green value of 0x22, a blue value of 0xAA, and an
    -- alpha value of 0xBB.
    BurninDestinationSettings -> Maybe Text
hexFontColor :: Prelude.Maybe Prelude.Text,
    -- | Specify the color of the burned-in captions text. Leave Font color
    -- (FontColor) blank and set Style passthrough (StylePassthrough) to
    -- enabled to use the font color data from your input captions, if present.
    BurninDestinationSettings -> Maybe BurninSubtitleFontColor
fontColor :: Prelude.Maybe BurninSubtitleFontColor
  }
  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' - Specify the opacity of the background rectangle. Enter a value from 0 to
-- 255, where 0 is transparent and 255 is opaque. If Style passthrough
-- (StylePassthrough) is set to enabled, leave blank to pass through the
-- background style information in your input captions to your output
-- captions. If Style passthrough is set to disabled, leave blank to use a
-- value of 0 and remove all backgrounds from your output captions.
--
-- 'fallbackFont', 'burninDestinationSettings_fallbackFont' - Specify the font that you want the service to use for your burn in
-- captions when your input captions specify a font that MediaConvert
-- doesn\'t support. When you set Fallback font (FallbackFont) to best
-- match (BEST_MATCH), or leave blank, MediaConvert uses a supported font
-- that most closely matches the font that your input captions specify.
-- When there are multiple unsupported fonts in your input captions,
-- MediaConvert matches each font with the supported font that matches
-- best. When you explicitly choose a replacement font, MediaConvert uses
-- that font to replace all unsupported fonts from your input.
--
-- 'fontOpacity', 'burninDestinationSettings_fontOpacity' - Specify the opacity of the burned-in captions. 255 is opaque; 0 is
-- transparent.
--
-- 'shadowYOffset', 'burninDestinationSettings_shadowYOffset' - Specify 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. Leave Shadow y-offset (ShadowYOffset) blank and set Style
-- passthrough (StylePassthrough) to enabled to use the shadow y-offset
-- data from your input captions, if present.
--
-- 'fontResolution', 'burninDestinationSettings_fontResolution' - Specify the Font resolution (FontResolution) in DPI (dots per inch).
--
-- 'yPosition', 'burninDestinationSettings_yPosition' - Specify the vertical position (YPosition) of the captions, 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
-- y_position is provided, the caption will be positioned towards the
-- bottom of the output.
--
-- 'backgroundColor', 'burninDestinationSettings_backgroundColor' - Specify the color of the rectangle behind the captions. Leave background
-- color (BackgroundColor) blank and set Style passthrough
-- (StylePassthrough) to enabled to use the background color data from your
-- input captions, if present. Within your job settings, all of your
-- DVB-Sub settings must be identical.
--
-- 'shadowXOffset', 'burninDestinationSettings_shadowXOffset' - Specify 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.
--
-- 'fontSize', 'burninDestinationSettings_fontSize' - Specify the Font size (FontSize) in pixels. Must be a positive integer.
-- Set to 0, or leave blank, for automatic font size.
--
-- 'xPosition', 'burninDestinationSettings_xPosition' - Specify the horizontal position (XPosition) of the captions, 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
-- x_position is provided, the horizontal caption position will be
-- determined by the alignment parameter.
--
-- 'teletextSpacing', 'burninDestinationSettings_teletextSpacing' - Specify whether the text spacing (TeletextSpacing) in your captions is
-- set by the captions grid, or varies depending on letter width. Choose
-- fixed grid (FIXED_GRID) to conform to the spacing specified in the
-- captions file more accurately. Choose proportional (PROPORTIONAL) to
-- make the text easier to read for closed captions.
--
-- 'fontScript', 'burninDestinationSettings_fontScript' - Set Font script (FontScript) to Automatically determined (AUTOMATIC), or
-- leave blank, to automatically determine the font script in your input
-- captions. Otherwise, set to Simplified Chinese (HANS) or Traditional
-- Chinese (HANT) if your input font script uses Simplified or Traditional
-- Chinese.
--
-- 'alignment', 'burninDestinationSettings_alignment' - Specify the alignment of your captions. If no explicit x_position is
-- provided, setting alignment to centered will placethe captions at the
-- bottom center of the output. Similarly, setting a left alignment
-- willalign 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.
--
-- 'shadowOpacity', 'burninDestinationSettings_shadowOpacity' - Specify the opacity of the shadow. Enter a value from 0 to 255, where 0
-- is transparent and 255 is opaque. If Style passthrough
-- (StylePassthrough) is set to Enabled, leave Shadow opacity
-- (ShadowOpacity) blank to pass through the shadow style information in
-- your input captions to your output captions. If Style passthrough is set
-- to disabled, leave blank to use a value of 0 and remove all shadows from
-- your output captions.
--
-- 'applyFontColor', 'burninDestinationSettings_applyFontColor' - Ignore this setting unless Style passthrough (StylePassthrough) is set
-- to Enabled and Font color (FontColor) set to Black, Yellow, Red, Green,
-- Blue, or Hex. Use Apply font color (ApplyFontColor) for additional font
-- color controls. When you choose White text only (WHITE_TEXT_ONLY), or
-- leave blank, your font color setting only applies to white text in your
-- input captions. For example, if your font color setting is Yellow, and
-- your input captions have red and white text, your output captions will
-- have red and yellow text. When you choose ALL_TEXT, your font color
-- setting applies to all of your output captions text.
--
-- 'stylePassthrough', 'burninDestinationSettings_stylePassthrough' - Set Style passthrough (StylePassthrough) to ENABLED to use the available
-- style, color, and position information from your input captions.
-- MediaConvert uses default settings for any missing style and position
-- information in your input captions. Set Style passthrough to DISABLED,
-- or leave blank, to ignore the style and position information from your
-- input captions and use default settings: white text with black
-- outlining, bottom-center positioning, and automatic sizing. Whether you
-- set Style passthrough to enabled or not, you can also choose to manually
-- override any of the individual style and position settings.
--
-- 'outlineColor', 'burninDestinationSettings_outlineColor' - Specify font outline color. Leave Outline color (OutlineColor) blank and
-- set Style passthrough (StylePassthrough) to enabled to use the font
-- outline color data from your input captions, if present.
--
-- 'outlineSize', 'burninDestinationSettings_outlineSize' - Specify the Outline size (OutlineSize) of the caption text, in pixels.
-- Leave Outline size blank and set Style passthrough (StylePassthrough) to
-- enabled to use the outline size data from your input captions, if
-- present.
--
-- 'shadowColor', 'burninDestinationSettings_shadowColor' - Specify the color of the shadow cast by the captions. Leave Shadow color
-- (ShadowColor) blank and set Style passthrough (StylePassthrough) to
-- enabled to use the shadow color data from your input captions, if
-- present.
--
-- 'hexFontColor', 'burninDestinationSettings_hexFontColor' - Ignore this setting unless your Font color is set to Hex. Enter either
-- six or eight hexidecimal digits, representing red, green, and blue, with
-- two optional extra digits for alpha. For example a value of 1122AABB is
-- a red value of 0x11, a green value of 0x22, a blue value of 0xAA, and an
-- alpha value of 0xBB.
--
-- 'fontColor', 'burninDestinationSettings_fontColor' - Specify the color of the burned-in captions text. Leave Font color
-- (FontColor) blank and set Style passthrough (StylePassthrough) to
-- enabled to use the font color data from your input captions, if present.
newBurninDestinationSettings ::
  BurninDestinationSettings
newBurninDestinationSettings :: BurninDestinationSettings
newBurninDestinationSettings =
  BurninDestinationSettings' :: Maybe Natural
-> Maybe BurninSubtitleFallbackFont
-> Maybe Natural
-> Maybe Int
-> Maybe Natural
-> Maybe Natural
-> Maybe BurninSubtitleBackgroundColor
-> Maybe Int
-> Maybe Natural
-> Maybe Natural
-> Maybe BurninSubtitleTeletextSpacing
-> Maybe FontScript
-> Maybe BurninSubtitleAlignment
-> Maybe Natural
-> Maybe BurninSubtitleApplyFontColor
-> Maybe BurnInSubtitleStylePassthrough
-> Maybe BurninSubtitleOutlineColor
-> Maybe Natural
-> Maybe BurninSubtitleShadowColor
-> Maybe Text
-> Maybe BurninSubtitleFontColor
-> BurninDestinationSettings
BurninDestinationSettings'
    { $sel:backgroundOpacity:BurninDestinationSettings' :: Maybe Natural
backgroundOpacity =
        Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:fallbackFont:BurninDestinationSettings' :: Maybe BurninSubtitleFallbackFont
fallbackFont = Maybe BurninSubtitleFallbackFont
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 BurninSubtitleBackgroundColor
backgroundColor = Maybe BurninSubtitleBackgroundColor
forall a. Maybe a
Prelude.Nothing,
      $sel:shadowXOffset:BurninDestinationSettings' :: Maybe Int
shadowXOffset = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:fontSize:BurninDestinationSettings' :: Maybe Natural
fontSize = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:xPosition:BurninDestinationSettings' :: Maybe Natural
xPosition = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:teletextSpacing:BurninDestinationSettings' :: Maybe BurninSubtitleTeletextSpacing
teletextSpacing = Maybe BurninSubtitleTeletextSpacing
forall a. Maybe a
Prelude.Nothing,
      $sel:fontScript:BurninDestinationSettings' :: Maybe FontScript
fontScript = Maybe FontScript
forall a. Maybe a
Prelude.Nothing,
      $sel:alignment:BurninDestinationSettings' :: Maybe BurninSubtitleAlignment
alignment = Maybe BurninSubtitleAlignment
forall a. Maybe a
Prelude.Nothing,
      $sel:shadowOpacity:BurninDestinationSettings' :: Maybe Natural
shadowOpacity = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:applyFontColor:BurninDestinationSettings' :: Maybe BurninSubtitleApplyFontColor
applyFontColor = Maybe BurninSubtitleApplyFontColor
forall a. Maybe a
Prelude.Nothing,
      $sel:stylePassthrough:BurninDestinationSettings' :: Maybe BurnInSubtitleStylePassthrough
stylePassthrough = Maybe BurnInSubtitleStylePassthrough
forall a. Maybe a
Prelude.Nothing,
      $sel:outlineColor:BurninDestinationSettings' :: Maybe BurninSubtitleOutlineColor
outlineColor = Maybe BurninSubtitleOutlineColor
forall a. Maybe a
Prelude.Nothing,
      $sel:outlineSize:BurninDestinationSettings' :: Maybe Natural
outlineSize = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:shadowColor:BurninDestinationSettings' :: Maybe BurninSubtitleShadowColor
shadowColor = Maybe BurninSubtitleShadowColor
forall a. Maybe a
Prelude.Nothing,
      $sel:hexFontColor:BurninDestinationSettings' :: Maybe Text
hexFontColor = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:fontColor:BurninDestinationSettings' :: Maybe BurninSubtitleFontColor
fontColor = Maybe BurninSubtitleFontColor
forall a. Maybe a
Prelude.Nothing
    }

-- | Specify the opacity of the background rectangle. Enter a value from 0 to
-- 255, where 0 is transparent and 255 is opaque. If Style passthrough
-- (StylePassthrough) is set to enabled, leave blank to pass through the
-- background style information in your input captions to your output
-- captions. If Style passthrough is set to disabled, leave blank to use a
-- value of 0 and remove all backgrounds from your output captions.
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)

-- | Specify the font that you want the service to use for your burn in
-- captions when your input captions specify a font that MediaConvert
-- doesn\'t support. When you set Fallback font (FallbackFont) to best
-- match (BEST_MATCH), or leave blank, MediaConvert uses a supported font
-- that most closely matches the font that your input captions specify.
-- When there are multiple unsupported fonts in your input captions,
-- MediaConvert matches each font with the supported font that matches
-- best. When you explicitly choose a replacement font, MediaConvert uses
-- that font to replace all unsupported fonts from your input.
burninDestinationSettings_fallbackFont :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe BurninSubtitleFallbackFont)
burninDestinationSettings_fallbackFont :: (Maybe BurninSubtitleFallbackFont
 -> f (Maybe BurninSubtitleFallbackFont))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_fallbackFont = (BurninDestinationSettings -> Maybe BurninSubtitleFallbackFont)
-> (BurninDestinationSettings
    -> Maybe BurninSubtitleFallbackFont -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe BurninSubtitleFallbackFont)
     (Maybe BurninSubtitleFallbackFont)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe BurninSubtitleFallbackFont
fallbackFont :: Maybe BurninSubtitleFallbackFont
$sel:fallbackFont:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleFallbackFont
fallbackFont} -> Maybe BurninSubtitleFallbackFont
fallbackFont) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe BurninSubtitleFallbackFont
a -> BurninDestinationSettings
s {$sel:fallbackFont:BurninDestinationSettings' :: Maybe BurninSubtitleFallbackFont
fallbackFont = Maybe BurninSubtitleFallbackFont
a} :: BurninDestinationSettings)

-- | Specify the opacity of the burned-in captions. 255 is opaque; 0 is
-- transparent.
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)

-- | Specify 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. Leave Shadow y-offset (ShadowYOffset) blank and set Style
-- passthrough (StylePassthrough) to enabled to use the shadow y-offset
-- data from your input captions, if present.
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)

-- | Specify the Font resolution (FontResolution) in DPI (dots per inch).
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)

-- | Specify the vertical position (YPosition) of the captions, 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
-- y_position is provided, the caption will be positioned towards the
-- bottom of the output.
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)

-- | Specify the color of the rectangle behind the captions. Leave background
-- color (BackgroundColor) blank and set Style passthrough
-- (StylePassthrough) to enabled to use the background color data from your
-- input captions, if present. Within your job settings, all of your
-- DVB-Sub settings must be identical.
burninDestinationSettings_backgroundColor :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe BurninSubtitleBackgroundColor)
burninDestinationSettings_backgroundColor :: (Maybe BurninSubtitleBackgroundColor
 -> f (Maybe BurninSubtitleBackgroundColor))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_backgroundColor = (BurninDestinationSettings -> Maybe BurninSubtitleBackgroundColor)
-> (BurninDestinationSettings
    -> Maybe BurninSubtitleBackgroundColor
    -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe BurninSubtitleBackgroundColor)
     (Maybe BurninSubtitleBackgroundColor)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe BurninSubtitleBackgroundColor
backgroundColor :: Maybe BurninSubtitleBackgroundColor
$sel:backgroundColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleBackgroundColor
backgroundColor} -> Maybe BurninSubtitleBackgroundColor
backgroundColor) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe BurninSubtitleBackgroundColor
a -> BurninDestinationSettings
s {$sel:backgroundColor:BurninDestinationSettings' :: Maybe BurninSubtitleBackgroundColor
backgroundColor = Maybe BurninSubtitleBackgroundColor
a} :: BurninDestinationSettings)

-- | Specify 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.
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)

-- | Specify the Font size (FontSize) in pixels. Must be a positive integer.
-- Set to 0, or leave blank, for automatic font size.
burninDestinationSettings_fontSize :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe Prelude.Natural)
burninDestinationSettings_fontSize :: (Maybe Natural -> f (Maybe Natural))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_fontSize = (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
fontSize :: Maybe Natural
$sel:fontSize:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe Natural
fontSize} -> Maybe Natural
fontSize) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe Natural
a -> BurninDestinationSettings
s {$sel:fontSize:BurninDestinationSettings' :: Maybe Natural
fontSize = Maybe Natural
a} :: BurninDestinationSettings)

-- | Specify the horizontal position (XPosition) of the captions, 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
-- x_position is provided, the horizontal caption position will be
-- determined by the alignment parameter.
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)

-- | Specify whether the text spacing (TeletextSpacing) in your captions is
-- set by the captions grid, or varies depending on letter width. Choose
-- fixed grid (FIXED_GRID) to conform to the spacing specified in the
-- captions file more accurately. Choose proportional (PROPORTIONAL) to
-- make the text easier to read for closed captions.
burninDestinationSettings_teletextSpacing :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe BurninSubtitleTeletextSpacing)
burninDestinationSettings_teletextSpacing :: (Maybe BurninSubtitleTeletextSpacing
 -> f (Maybe BurninSubtitleTeletextSpacing))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_teletextSpacing = (BurninDestinationSettings -> Maybe BurninSubtitleTeletextSpacing)
-> (BurninDestinationSettings
    -> Maybe BurninSubtitleTeletextSpacing
    -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe BurninSubtitleTeletextSpacing)
     (Maybe BurninSubtitleTeletextSpacing)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe BurninSubtitleTeletextSpacing
teletextSpacing :: Maybe BurninSubtitleTeletextSpacing
$sel:teletextSpacing:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleTeletextSpacing
teletextSpacing} -> Maybe BurninSubtitleTeletextSpacing
teletextSpacing) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe BurninSubtitleTeletextSpacing
a -> BurninDestinationSettings
s {$sel:teletextSpacing:BurninDestinationSettings' :: Maybe BurninSubtitleTeletextSpacing
teletextSpacing = Maybe BurninSubtitleTeletextSpacing
a} :: BurninDestinationSettings)

-- | Set Font script (FontScript) to Automatically determined (AUTOMATIC), or
-- leave blank, to automatically determine the font script in your input
-- captions. Otherwise, set to Simplified Chinese (HANS) or Traditional
-- Chinese (HANT) if your input font script uses Simplified or Traditional
-- Chinese.
burninDestinationSettings_fontScript :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe FontScript)
burninDestinationSettings_fontScript :: (Maybe FontScript -> f (Maybe FontScript))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_fontScript = (BurninDestinationSettings -> Maybe FontScript)
-> (BurninDestinationSettings
    -> Maybe FontScript -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe FontScript)
     (Maybe FontScript)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe FontScript
fontScript :: Maybe FontScript
$sel:fontScript:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe FontScript
fontScript} -> Maybe FontScript
fontScript) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe FontScript
a -> BurninDestinationSettings
s {$sel:fontScript:BurninDestinationSettings' :: Maybe FontScript
fontScript = Maybe FontScript
a} :: BurninDestinationSettings)

-- | Specify the alignment of your captions. If no explicit x_position is
-- provided, setting alignment to centered will placethe captions at the
-- bottom center of the output. Similarly, setting a left alignment
-- willalign 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.
burninDestinationSettings_alignment :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe BurninSubtitleAlignment)
burninDestinationSettings_alignment :: (Maybe BurninSubtitleAlignment
 -> f (Maybe BurninSubtitleAlignment))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_alignment = (BurninDestinationSettings -> Maybe BurninSubtitleAlignment)
-> (BurninDestinationSettings
    -> Maybe BurninSubtitleAlignment -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe BurninSubtitleAlignment)
     (Maybe BurninSubtitleAlignment)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe BurninSubtitleAlignment
alignment :: Maybe BurninSubtitleAlignment
$sel:alignment:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleAlignment
alignment} -> Maybe BurninSubtitleAlignment
alignment) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe BurninSubtitleAlignment
a -> BurninDestinationSettings
s {$sel:alignment:BurninDestinationSettings' :: Maybe BurninSubtitleAlignment
alignment = Maybe BurninSubtitleAlignment
a} :: BurninDestinationSettings)

-- | Specify the opacity of the shadow. Enter a value from 0 to 255, where 0
-- is transparent and 255 is opaque. If Style passthrough
-- (StylePassthrough) is set to Enabled, leave Shadow opacity
-- (ShadowOpacity) blank to pass through the shadow style information in
-- your input captions to your output captions. If Style passthrough is set
-- to disabled, leave blank to use a value of 0 and remove all shadows from
-- your output captions.
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)

-- | Ignore this setting unless Style passthrough (StylePassthrough) is set
-- to Enabled and Font color (FontColor) set to Black, Yellow, Red, Green,
-- Blue, or Hex. Use Apply font color (ApplyFontColor) for additional font
-- color controls. When you choose White text only (WHITE_TEXT_ONLY), or
-- leave blank, your font color setting only applies to white text in your
-- input captions. For example, if your font color setting is Yellow, and
-- your input captions have red and white text, your output captions will
-- have red and yellow text. When you choose ALL_TEXT, your font color
-- setting applies to all of your output captions text.
burninDestinationSettings_applyFontColor :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe BurninSubtitleApplyFontColor)
burninDestinationSettings_applyFontColor :: (Maybe BurninSubtitleApplyFontColor
 -> f (Maybe BurninSubtitleApplyFontColor))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_applyFontColor = (BurninDestinationSettings -> Maybe BurninSubtitleApplyFontColor)
-> (BurninDestinationSettings
    -> Maybe BurninSubtitleApplyFontColor -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe BurninSubtitleApplyFontColor)
     (Maybe BurninSubtitleApplyFontColor)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe BurninSubtitleApplyFontColor
applyFontColor :: Maybe BurninSubtitleApplyFontColor
$sel:applyFontColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleApplyFontColor
applyFontColor} -> Maybe BurninSubtitleApplyFontColor
applyFontColor) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe BurninSubtitleApplyFontColor
a -> BurninDestinationSettings
s {$sel:applyFontColor:BurninDestinationSettings' :: Maybe BurninSubtitleApplyFontColor
applyFontColor = Maybe BurninSubtitleApplyFontColor
a} :: BurninDestinationSettings)

-- | Set Style passthrough (StylePassthrough) to ENABLED to use the available
-- style, color, and position information from your input captions.
-- MediaConvert uses default settings for any missing style and position
-- information in your input captions. Set Style passthrough to DISABLED,
-- or leave blank, to ignore the style and position information from your
-- input captions and use default settings: white text with black
-- outlining, bottom-center positioning, and automatic sizing. Whether you
-- set Style passthrough to enabled or not, you can also choose to manually
-- override any of the individual style and position settings.
burninDestinationSettings_stylePassthrough :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe BurnInSubtitleStylePassthrough)
burninDestinationSettings_stylePassthrough :: (Maybe BurnInSubtitleStylePassthrough
 -> f (Maybe BurnInSubtitleStylePassthrough))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_stylePassthrough = (BurninDestinationSettings -> Maybe BurnInSubtitleStylePassthrough)
-> (BurninDestinationSettings
    -> Maybe BurnInSubtitleStylePassthrough
    -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe BurnInSubtitleStylePassthrough)
     (Maybe BurnInSubtitleStylePassthrough)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe BurnInSubtitleStylePassthrough
stylePassthrough :: Maybe BurnInSubtitleStylePassthrough
$sel:stylePassthrough:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurnInSubtitleStylePassthrough
stylePassthrough} -> Maybe BurnInSubtitleStylePassthrough
stylePassthrough) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe BurnInSubtitleStylePassthrough
a -> BurninDestinationSettings
s {$sel:stylePassthrough:BurninDestinationSettings' :: Maybe BurnInSubtitleStylePassthrough
stylePassthrough = Maybe BurnInSubtitleStylePassthrough
a} :: BurninDestinationSettings)

-- | Specify font outline color. Leave Outline color (OutlineColor) blank and
-- set Style passthrough (StylePassthrough) to enabled to use the font
-- outline color data from your input captions, if present.
burninDestinationSettings_outlineColor :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe BurninSubtitleOutlineColor)
burninDestinationSettings_outlineColor :: (Maybe BurninSubtitleOutlineColor
 -> f (Maybe BurninSubtitleOutlineColor))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_outlineColor = (BurninDestinationSettings -> Maybe BurninSubtitleOutlineColor)
-> (BurninDestinationSettings
    -> Maybe BurninSubtitleOutlineColor -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe BurninSubtitleOutlineColor)
     (Maybe BurninSubtitleOutlineColor)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe BurninSubtitleOutlineColor
outlineColor :: Maybe BurninSubtitleOutlineColor
$sel:outlineColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleOutlineColor
outlineColor} -> Maybe BurninSubtitleOutlineColor
outlineColor) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe BurninSubtitleOutlineColor
a -> BurninDestinationSettings
s {$sel:outlineColor:BurninDestinationSettings' :: Maybe BurninSubtitleOutlineColor
outlineColor = Maybe BurninSubtitleOutlineColor
a} :: BurninDestinationSettings)

-- | Specify the Outline size (OutlineSize) of the caption text, in pixels.
-- Leave Outline size blank and set Style passthrough (StylePassthrough) to
-- enabled to use the outline size data from your input captions, if
-- present.
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)

-- | Specify the color of the shadow cast by the captions. Leave Shadow color
-- (ShadowColor) blank and set Style passthrough (StylePassthrough) to
-- enabled to use the shadow color data from your input captions, if
-- present.
burninDestinationSettings_shadowColor :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe BurninSubtitleShadowColor)
burninDestinationSettings_shadowColor :: (Maybe BurninSubtitleShadowColor
 -> f (Maybe BurninSubtitleShadowColor))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_shadowColor = (BurninDestinationSettings -> Maybe BurninSubtitleShadowColor)
-> (BurninDestinationSettings
    -> Maybe BurninSubtitleShadowColor -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe BurninSubtitleShadowColor)
     (Maybe BurninSubtitleShadowColor)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe BurninSubtitleShadowColor
shadowColor :: Maybe BurninSubtitleShadowColor
$sel:shadowColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleShadowColor
shadowColor} -> Maybe BurninSubtitleShadowColor
shadowColor) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe BurninSubtitleShadowColor
a -> BurninDestinationSettings
s {$sel:shadowColor:BurninDestinationSettings' :: Maybe BurninSubtitleShadowColor
shadowColor = Maybe BurninSubtitleShadowColor
a} :: BurninDestinationSettings)

-- | Ignore this setting unless your Font color is set to Hex. Enter either
-- six or eight hexidecimal digits, representing red, green, and blue, with
-- two optional extra digits for alpha. For example a value of 1122AABB is
-- a red value of 0x11, a green value of 0x22, a blue value of 0xAA, and an
-- alpha value of 0xBB.
burninDestinationSettings_hexFontColor :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe Prelude.Text)
burninDestinationSettings_hexFontColor :: (Maybe Text -> f (Maybe Text))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_hexFontColor = (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
hexFontColor :: Maybe Text
$sel:hexFontColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe Text
hexFontColor} -> Maybe Text
hexFontColor) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe Text
a -> BurninDestinationSettings
s {$sel:hexFontColor:BurninDestinationSettings' :: Maybe Text
hexFontColor = Maybe Text
a} :: BurninDestinationSettings)

-- | Specify the color of the burned-in captions text. Leave Font color
-- (FontColor) blank and set Style passthrough (StylePassthrough) to
-- enabled to use the font color data from your input captions, if present.
burninDestinationSettings_fontColor :: Lens.Lens' BurninDestinationSettings (Prelude.Maybe BurninSubtitleFontColor)
burninDestinationSettings_fontColor :: (Maybe BurninSubtitleFontColor
 -> f (Maybe BurninSubtitleFontColor))
-> BurninDestinationSettings -> f BurninDestinationSettings
burninDestinationSettings_fontColor = (BurninDestinationSettings -> Maybe BurninSubtitleFontColor)
-> (BurninDestinationSettings
    -> Maybe BurninSubtitleFontColor -> BurninDestinationSettings)
-> Lens
     BurninDestinationSettings
     BurninDestinationSettings
     (Maybe BurninSubtitleFontColor)
     (Maybe BurninSubtitleFontColor)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BurninDestinationSettings' {Maybe BurninSubtitleFontColor
fontColor :: Maybe BurninSubtitleFontColor
$sel:fontColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleFontColor
fontColor} -> Maybe BurninSubtitleFontColor
fontColor) (\s :: BurninDestinationSettings
s@BurninDestinationSettings' {} Maybe BurninSubtitleFontColor
a -> BurninDestinationSettings
s {$sel:fontColor:BurninDestinationSettings' :: Maybe BurninSubtitleFontColor
fontColor = Maybe BurninSubtitleFontColor
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 BurninSubtitleFallbackFont
-> Maybe Natural
-> Maybe Int
-> Maybe Natural
-> Maybe Natural
-> Maybe BurninSubtitleBackgroundColor
-> Maybe Int
-> Maybe Natural
-> Maybe Natural
-> Maybe BurninSubtitleTeletextSpacing
-> Maybe FontScript
-> Maybe BurninSubtitleAlignment
-> Maybe Natural
-> Maybe BurninSubtitleApplyFontColor
-> Maybe BurnInSubtitleStylePassthrough
-> Maybe BurninSubtitleOutlineColor
-> Maybe Natural
-> Maybe BurninSubtitleShadowColor
-> Maybe Text
-> Maybe BurninSubtitleFontColor
-> BurninDestinationSettings
BurninDestinationSettings'
            (Maybe Natural
 -> Maybe BurninSubtitleFallbackFont
 -> Maybe Natural
 -> Maybe Int
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe BurninSubtitleBackgroundColor
 -> Maybe Int
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe BurninSubtitleTeletextSpacing
 -> Maybe FontScript
 -> Maybe BurninSubtitleAlignment
 -> Maybe Natural
 -> Maybe BurninSubtitleApplyFontColor
 -> Maybe BurnInSubtitleStylePassthrough
 -> Maybe BurninSubtitleOutlineColor
 -> Maybe Natural
 -> Maybe BurninSubtitleShadowColor
 -> Maybe Text
 -> Maybe BurninSubtitleFontColor
 -> BurninDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe BurninSubtitleFallbackFont
      -> Maybe Natural
      -> Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleBackgroundColor
      -> Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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 BurninSubtitleFallbackFont
   -> Maybe Natural
   -> Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleBackgroundColor
   -> Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe BurninSubtitleFallbackFont)
-> Parser
     (Maybe Natural
      -> Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleBackgroundColor
      -> Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> BurninDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurninSubtitleFallbackFont)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"fallbackFont")
            Parser
  (Maybe Natural
   -> Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleBackgroundColor
   -> Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleBackgroundColor
      -> Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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 BurninSubtitleBackgroundColor
   -> Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe Int)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleBackgroundColor
      -> Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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 BurninSubtitleBackgroundColor
   -> Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe BurninSubtitleBackgroundColor
      -> Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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 BurninSubtitleBackgroundColor
   -> Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe BurninSubtitleBackgroundColor
      -> Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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 BurninSubtitleBackgroundColor
   -> Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe BurninSubtitleBackgroundColor)
-> Parser
     (Maybe Int
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> BurninDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurninSubtitleBackgroundColor)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"backgroundColor")
            Parser
  (Maybe Int
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe Int)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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 Natural
   -> Maybe Natural
   -> Maybe BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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
"fontSize")
            Parser
  (Maybe Natural
   -> Maybe BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe BurninSubtitleTeletextSpacing
      -> Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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 BurninSubtitleTeletextSpacing
   -> Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe BurninSubtitleTeletextSpacing)
-> Parser
     (Maybe FontScript
      -> Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> BurninDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurninSubtitleTeletextSpacing)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"teletextSpacing")
            Parser
  (Maybe FontScript
   -> Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe FontScript)
-> Parser
     (Maybe BurninSubtitleAlignment
      -> Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> BurninDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe FontScript)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"fontScript")
            Parser
  (Maybe BurninSubtitleAlignment
   -> Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe BurninSubtitleAlignment)
-> Parser
     (Maybe Natural
      -> Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> BurninDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurninSubtitleAlignment)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"alignment")
            Parser
  (Maybe Natural
   -> Maybe BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe BurninSubtitleApplyFontColor
      -> Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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 BurninSubtitleApplyFontColor
   -> Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe BurninSubtitleApplyFontColor)
-> Parser
     (Maybe BurnInSubtitleStylePassthrough
      -> Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> BurninDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurninSubtitleApplyFontColor)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"applyFontColor")
            Parser
  (Maybe BurnInSubtitleStylePassthrough
   -> Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe BurnInSubtitleStylePassthrough)
-> Parser
     (Maybe BurninSubtitleOutlineColor
      -> Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> BurninDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurnInSubtitleStylePassthrough)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"stylePassthrough")
            Parser
  (Maybe BurninSubtitleOutlineColor
   -> Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe BurninSubtitleOutlineColor)
-> Parser
     (Maybe Natural
      -> Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> BurninDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurninSubtitleOutlineColor)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"outlineColor")
            Parser
  (Maybe Natural
   -> Maybe BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe BurninSubtitleShadowColor
      -> Maybe Text
      -> Maybe BurninSubtitleFontColor
      -> 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 BurninSubtitleShadowColor
   -> Maybe Text
   -> Maybe BurninSubtitleFontColor
   -> BurninDestinationSettings)
-> Parser (Maybe BurninSubtitleShadowColor)
-> Parser
     (Maybe Text
      -> Maybe BurninSubtitleFontColor -> BurninDestinationSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurninSubtitleShadowColor)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"shadowColor")
            Parser
  (Maybe Text
   -> Maybe BurninSubtitleFontColor -> BurninDestinationSettings)
-> Parser (Maybe Text)
-> Parser
     (Maybe BurninSubtitleFontColor -> 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
"hexFontColor")
            Parser (Maybe BurninSubtitleFontColor -> BurninDestinationSettings)
-> Parser (Maybe BurninSubtitleFontColor)
-> Parser BurninDestinationSettings
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe BurninSubtitleFontColor)
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 BurnInSubtitleStylePassthrough
Maybe BurninSubtitleAlignment
Maybe BurninSubtitleApplyFontColor
Maybe BurninSubtitleBackgroundColor
Maybe BurninSubtitleFallbackFont
Maybe BurninSubtitleFontColor
Maybe BurninSubtitleOutlineColor
Maybe BurninSubtitleShadowColor
Maybe BurninSubtitleTeletextSpacing
Maybe FontScript
fontColor :: Maybe BurninSubtitleFontColor
hexFontColor :: Maybe Text
shadowColor :: Maybe BurninSubtitleShadowColor
outlineSize :: Maybe Natural
outlineColor :: Maybe BurninSubtitleOutlineColor
stylePassthrough :: Maybe BurnInSubtitleStylePassthrough
applyFontColor :: Maybe BurninSubtitleApplyFontColor
shadowOpacity :: Maybe Natural
alignment :: Maybe BurninSubtitleAlignment
fontScript :: Maybe FontScript
teletextSpacing :: Maybe BurninSubtitleTeletextSpacing
xPosition :: Maybe Natural
fontSize :: Maybe Natural
shadowXOffset :: Maybe Int
backgroundColor :: Maybe BurninSubtitleBackgroundColor
yPosition :: Maybe Natural
fontResolution :: Maybe Natural
shadowYOffset :: Maybe Int
fontOpacity :: Maybe Natural
fallbackFont :: Maybe BurninSubtitleFallbackFont
backgroundOpacity :: Maybe Natural
$sel:fontColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleFontColor
$sel:hexFontColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe Text
$sel:shadowColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleShadowColor
$sel:outlineSize:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe Natural
$sel:outlineColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleOutlineColor
$sel:stylePassthrough:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurnInSubtitleStylePassthrough
$sel:applyFontColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleApplyFontColor
$sel:shadowOpacity:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe Natural
$sel:alignment:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleAlignment
$sel:fontScript:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe FontScript
$sel:teletextSpacing:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleTeletextSpacing
$sel:xPosition:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe Natural
$sel:fontSize:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe Natural
$sel:shadowXOffset:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe Int
$sel:backgroundColor:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleBackgroundColor
$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:fallbackFont:BurninDestinationSettings' :: BurninDestinationSettings -> Maybe BurninSubtitleFallbackFont
$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
"fallbackFont" Text -> BurninSubtitleFallbackFont -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BurninSubtitleFallbackFont -> Pair)
-> Maybe BurninSubtitleFallbackFont -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurninSubtitleFallbackFont
fallbackFont,
            (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 -> BurninSubtitleBackgroundColor -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (BurninSubtitleBackgroundColor -> Pair)
-> Maybe BurninSubtitleBackgroundColor -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurninSubtitleBackgroundColor
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 -> 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
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
"teletextSpacing" Text -> BurninSubtitleTeletextSpacing -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (BurninSubtitleTeletextSpacing -> Pair)
-> Maybe BurninSubtitleTeletextSpacing -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurninSubtitleTeletextSpacing
teletextSpacing,
            (Text
"fontScript" Text -> FontScript -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (FontScript -> Pair) -> Maybe FontScript -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe FontScript
fontScript,
            (Text
"alignment" Text -> BurninSubtitleAlignment -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BurninSubtitleAlignment -> Pair)
-> Maybe BurninSubtitleAlignment -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurninSubtitleAlignment
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
"applyFontColor" Text -> BurninSubtitleApplyFontColor -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (BurninSubtitleApplyFontColor -> Pair)
-> Maybe BurninSubtitleApplyFontColor -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurninSubtitleApplyFontColor
applyFontColor,
            (Text
"stylePassthrough" Text -> BurnInSubtitleStylePassthrough -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (BurnInSubtitleStylePassthrough -> Pair)
-> Maybe BurnInSubtitleStylePassthrough -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurnInSubtitleStylePassthrough
stylePassthrough,
            (Text
"outlineColor" Text -> BurninSubtitleOutlineColor -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BurninSubtitleOutlineColor -> Pair)
-> Maybe BurninSubtitleOutlineColor -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurninSubtitleOutlineColor
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
"shadowColor" Text -> BurninSubtitleShadowColor -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BurninSubtitleShadowColor -> Pair)
-> Maybe BurninSubtitleShadowColor -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurninSubtitleShadowColor
shadowColor,
            (Text
"hexFontColor" 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
hexFontColor,
            (Text
"fontColor" Text -> BurninSubtitleFontColor -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BurninSubtitleFontColor -> Pair)
-> Maybe BurninSubtitleFontColor -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BurninSubtitleFontColor
fontColor
          ]
      )