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

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaConvert.Types.NielsenActiveWatermarkProcessType
import Amazonka.MediaConvert.Types.NielsenSourceWatermarkStatusType
import Amazonka.MediaConvert.Types.NielsenUniqueTicPerAudioTrackType
import qualified Amazonka.Prelude as Prelude

-- | Ignore these settings unless you are using Nielsen non-linear
-- watermarking. Specify the values that MediaConvert uses to generate and
-- place Nielsen watermarks in your output audio. In addition to specifying
-- these values, you also need to set up your cloud TIC server. These
-- settings apply to every output in your job. The MediaConvert
-- implementation is currently with the following Nielsen versions: Nielsen
-- Watermark SDK Version 5.2.1 Nielsen NLM Watermark Engine Version 1.2.7
-- Nielsen Watermark Authenticator [SID_TIC] Version [5.0.0]
--
-- /See:/ 'newNielsenNonLinearWatermarkSettings' smart constructor.
data NielsenNonLinearWatermarkSettings = NielsenNonLinearWatermarkSettings'
  { -- | Optional. If this asset uses an episode ID with Nielsen, provide it
    -- here.
    NielsenNonLinearWatermarkSettings -> Maybe Text
episodeId :: Prelude.Maybe Prelude.Text,
    -- | Choose the type of Nielsen watermarks that you want in your outputs.
    -- When you choose NAES 2 and NW (NAES2_AND_NW), you must provide a value
    -- for the setting SID (sourceId). When you choose CBET (CBET), you must
    -- provide a value for the setting CSID (cbetSourceId). When you choose
    -- NAES 2, NW, and CBET (NAES2_AND_NW_AND_CBET), you must provide values
    -- for both of these settings.
    NielsenNonLinearWatermarkSettings
-> Maybe NielsenActiveWatermarkProcessType
activeWatermarkProcess :: Prelude.Maybe NielsenActiveWatermarkProcessType,
    -- | Use the SID that Nielsen provides to you. This source ID should be
    -- unique to your Nielsen account but common to all of your output assets.
    -- Required for all Nielsen non-linear watermarking. This ID should be
    -- unique to your Nielsen account but common to all of your output assets.
    -- Required for all Nielsen non-linear watermarking.
    NielsenNonLinearWatermarkSettings -> Maybe Natural
sourceId :: Prelude.Maybe Prelude.Natural,
    -- | Use the CSID that Nielsen provides to you. This CBET source ID should be
    -- unique to your Nielsen account but common to all of your output assets
    -- that have CBET watermarking. Required when you choose a value for the
    -- setting Watermark types (ActiveWatermarkProcess) that includes CBET.
    NielsenNonLinearWatermarkSettings -> Maybe Text
cbetSourceId :: Prelude.Maybe Prelude.Text,
    -- | Specify the endpoint for the TIC server that you have deployed and
    -- configured in the AWS Cloud. Required for all Nielsen non-linear
    -- watermarking. MediaConvert can\'t connect directly to a TIC server.
    -- Instead, you must use API Gateway to provide a RESTful interface between
    -- MediaConvert and a TIC server that you deploy in your AWS account. For
    -- more information on deploying a TIC server in your AWS account and the
    -- required API Gateway, contact Nielsen support.
    NielsenNonLinearWatermarkSettings -> Maybe Text
ticServerUrl :: Prelude.Maybe Prelude.Text,
    -- | Specify the Amazon S3 location where you want MediaConvert to save your
    -- Nielsen non-linear metadata .zip file. This Amazon S3 bucket must be in
    -- the same Region as the one where you do your MediaConvert transcoding.
    -- If you want to include an ADI file in this .zip file, use the setting
    -- ADI file (adiFilename) to specify it. MediaConvert delivers the Nielsen
    -- metadata .zip files only to your metadata destination Amazon S3 bucket.
    -- It doesn\'t deliver the .zip files to Nielsen. You are responsible for
    -- delivering the metadata .zip files to Nielsen.
    NielsenNonLinearWatermarkSettings -> Maybe Text
metadataDestination :: Prelude.Maybe Prelude.Text,
    -- | Use the asset name that you provide to Nielsen for this asset. Required
    -- for all Nielsen non-linear watermarking.
    NielsenNonLinearWatermarkSettings -> Maybe Text
assetName :: Prelude.Maybe Prelude.Text,
    -- | Optional. Use this setting when you want the service to include an ADI
    -- file in the Nielsen metadata .zip file. To provide an ADI file, store it
    -- in Amazon S3 and provide a URL to it here. The URL should be in the
    -- following format: S3:\/\/bucket\/path\/ADI-file. For more information
    -- about the metadata .zip file, see the setting Metadata destination
    -- (metadataDestination).
    NielsenNonLinearWatermarkSettings -> Maybe Text
adiFilename :: Prelude.Maybe Prelude.Text,
    -- | Use the asset ID that you provide to Nielsen to uniquely identify this
    -- asset. Required for all Nielsen non-linear watermarking.
    NielsenNonLinearWatermarkSettings -> Maybe Text
assetId :: Prelude.Maybe Prelude.Text,
    -- | To create assets that have the same TIC values in each audio track, keep
    -- the default value Share TICs (SAME_TICS_PER_TRACK). To create assets
    -- that have unique TIC values for each audio track, choose Use unique TICs
    -- (RESERVE_UNIQUE_TICS_PER_TRACK).
    NielsenNonLinearWatermarkSettings
-> Maybe NielsenUniqueTicPerAudioTrackType
uniqueTicPerAudioTrack :: Prelude.Maybe NielsenUniqueTicPerAudioTrackType,
    -- | Required. Specify whether your source content already contains Nielsen
    -- non-linear watermarks. When you set this value to Watermarked
    -- (WATERMARKED), the service fails the job. Nielsen requires that you add
    -- non-linear watermarking to only clean content that doesn\'t already have
    -- non-linear Nielsen watermarks.
    NielsenNonLinearWatermarkSettings
-> Maybe NielsenSourceWatermarkStatusType
sourceWatermarkStatus :: Prelude.Maybe NielsenSourceWatermarkStatusType
  }
  deriving (NielsenNonLinearWatermarkSettings
-> NielsenNonLinearWatermarkSettings -> Bool
(NielsenNonLinearWatermarkSettings
 -> NielsenNonLinearWatermarkSettings -> Bool)
-> (NielsenNonLinearWatermarkSettings
    -> NielsenNonLinearWatermarkSettings -> Bool)
-> Eq NielsenNonLinearWatermarkSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NielsenNonLinearWatermarkSettings
-> NielsenNonLinearWatermarkSettings -> Bool
$c/= :: NielsenNonLinearWatermarkSettings
-> NielsenNonLinearWatermarkSettings -> Bool
== :: NielsenNonLinearWatermarkSettings
-> NielsenNonLinearWatermarkSettings -> Bool
$c== :: NielsenNonLinearWatermarkSettings
-> NielsenNonLinearWatermarkSettings -> Bool
Prelude.Eq, ReadPrec [NielsenNonLinearWatermarkSettings]
ReadPrec NielsenNonLinearWatermarkSettings
Int -> ReadS NielsenNonLinearWatermarkSettings
ReadS [NielsenNonLinearWatermarkSettings]
(Int -> ReadS NielsenNonLinearWatermarkSettings)
-> ReadS [NielsenNonLinearWatermarkSettings]
-> ReadPrec NielsenNonLinearWatermarkSettings
-> ReadPrec [NielsenNonLinearWatermarkSettings]
-> Read NielsenNonLinearWatermarkSettings
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NielsenNonLinearWatermarkSettings]
$creadListPrec :: ReadPrec [NielsenNonLinearWatermarkSettings]
readPrec :: ReadPrec NielsenNonLinearWatermarkSettings
$creadPrec :: ReadPrec NielsenNonLinearWatermarkSettings
readList :: ReadS [NielsenNonLinearWatermarkSettings]
$creadList :: ReadS [NielsenNonLinearWatermarkSettings]
readsPrec :: Int -> ReadS NielsenNonLinearWatermarkSettings
$creadsPrec :: Int -> ReadS NielsenNonLinearWatermarkSettings
Prelude.Read, Int -> NielsenNonLinearWatermarkSettings -> ShowS
[NielsenNonLinearWatermarkSettings] -> ShowS
NielsenNonLinearWatermarkSettings -> String
(Int -> NielsenNonLinearWatermarkSettings -> ShowS)
-> (NielsenNonLinearWatermarkSettings -> String)
-> ([NielsenNonLinearWatermarkSettings] -> ShowS)
-> Show NielsenNonLinearWatermarkSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NielsenNonLinearWatermarkSettings] -> ShowS
$cshowList :: [NielsenNonLinearWatermarkSettings] -> ShowS
show :: NielsenNonLinearWatermarkSettings -> String
$cshow :: NielsenNonLinearWatermarkSettings -> String
showsPrec :: Int -> NielsenNonLinearWatermarkSettings -> ShowS
$cshowsPrec :: Int -> NielsenNonLinearWatermarkSettings -> ShowS
Prelude.Show, (forall x.
 NielsenNonLinearWatermarkSettings
 -> Rep NielsenNonLinearWatermarkSettings x)
-> (forall x.
    Rep NielsenNonLinearWatermarkSettings x
    -> NielsenNonLinearWatermarkSettings)
-> Generic NielsenNonLinearWatermarkSettings
forall x.
Rep NielsenNonLinearWatermarkSettings x
-> NielsenNonLinearWatermarkSettings
forall x.
NielsenNonLinearWatermarkSettings
-> Rep NielsenNonLinearWatermarkSettings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep NielsenNonLinearWatermarkSettings x
-> NielsenNonLinearWatermarkSettings
$cfrom :: forall x.
NielsenNonLinearWatermarkSettings
-> Rep NielsenNonLinearWatermarkSettings x
Prelude.Generic)

-- |
-- Create a value of 'NielsenNonLinearWatermarkSettings' 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:
--
-- 'episodeId', 'nielsenNonLinearWatermarkSettings_episodeId' - Optional. If this asset uses an episode ID with Nielsen, provide it
-- here.
--
-- 'activeWatermarkProcess', 'nielsenNonLinearWatermarkSettings_activeWatermarkProcess' - Choose the type of Nielsen watermarks that you want in your outputs.
-- When you choose NAES 2 and NW (NAES2_AND_NW), you must provide a value
-- for the setting SID (sourceId). When you choose CBET (CBET), you must
-- provide a value for the setting CSID (cbetSourceId). When you choose
-- NAES 2, NW, and CBET (NAES2_AND_NW_AND_CBET), you must provide values
-- for both of these settings.
--
-- 'sourceId', 'nielsenNonLinearWatermarkSettings_sourceId' - Use the SID that Nielsen provides to you. This source ID should be
-- unique to your Nielsen account but common to all of your output assets.
-- Required for all Nielsen non-linear watermarking. This ID should be
-- unique to your Nielsen account but common to all of your output assets.
-- Required for all Nielsen non-linear watermarking.
--
-- 'cbetSourceId', 'nielsenNonLinearWatermarkSettings_cbetSourceId' - Use the CSID that Nielsen provides to you. This CBET source ID should be
-- unique to your Nielsen account but common to all of your output assets
-- that have CBET watermarking. Required when you choose a value for the
-- setting Watermark types (ActiveWatermarkProcess) that includes CBET.
--
-- 'ticServerUrl', 'nielsenNonLinearWatermarkSettings_ticServerUrl' - Specify the endpoint for the TIC server that you have deployed and
-- configured in the AWS Cloud. Required for all Nielsen non-linear
-- watermarking. MediaConvert can\'t connect directly to a TIC server.
-- Instead, you must use API Gateway to provide a RESTful interface between
-- MediaConvert and a TIC server that you deploy in your AWS account. For
-- more information on deploying a TIC server in your AWS account and the
-- required API Gateway, contact Nielsen support.
--
-- 'metadataDestination', 'nielsenNonLinearWatermarkSettings_metadataDestination' - Specify the Amazon S3 location where you want MediaConvert to save your
-- Nielsen non-linear metadata .zip file. This Amazon S3 bucket must be in
-- the same Region as the one where you do your MediaConvert transcoding.
-- If you want to include an ADI file in this .zip file, use the setting
-- ADI file (adiFilename) to specify it. MediaConvert delivers the Nielsen
-- metadata .zip files only to your metadata destination Amazon S3 bucket.
-- It doesn\'t deliver the .zip files to Nielsen. You are responsible for
-- delivering the metadata .zip files to Nielsen.
--
-- 'assetName', 'nielsenNonLinearWatermarkSettings_assetName' - Use the asset name that you provide to Nielsen for this asset. Required
-- for all Nielsen non-linear watermarking.
--
-- 'adiFilename', 'nielsenNonLinearWatermarkSettings_adiFilename' - Optional. Use this setting when you want the service to include an ADI
-- file in the Nielsen metadata .zip file. To provide an ADI file, store it
-- in Amazon S3 and provide a URL to it here. The URL should be in the
-- following format: S3:\/\/bucket\/path\/ADI-file. For more information
-- about the metadata .zip file, see the setting Metadata destination
-- (metadataDestination).
--
-- 'assetId', 'nielsenNonLinearWatermarkSettings_assetId' - Use the asset ID that you provide to Nielsen to uniquely identify this
-- asset. Required for all Nielsen non-linear watermarking.
--
-- 'uniqueTicPerAudioTrack', 'nielsenNonLinearWatermarkSettings_uniqueTicPerAudioTrack' - To create assets that have the same TIC values in each audio track, keep
-- the default value Share TICs (SAME_TICS_PER_TRACK). To create assets
-- that have unique TIC values for each audio track, choose Use unique TICs
-- (RESERVE_UNIQUE_TICS_PER_TRACK).
--
-- 'sourceWatermarkStatus', 'nielsenNonLinearWatermarkSettings_sourceWatermarkStatus' - Required. Specify whether your source content already contains Nielsen
-- non-linear watermarks. When you set this value to Watermarked
-- (WATERMARKED), the service fails the job. Nielsen requires that you add
-- non-linear watermarking to only clean content that doesn\'t already have
-- non-linear Nielsen watermarks.
newNielsenNonLinearWatermarkSettings ::
  NielsenNonLinearWatermarkSettings
newNielsenNonLinearWatermarkSettings :: NielsenNonLinearWatermarkSettings
newNielsenNonLinearWatermarkSettings =
  NielsenNonLinearWatermarkSettings' :: Maybe Text
-> Maybe NielsenActiveWatermarkProcessType
-> Maybe Natural
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe NielsenUniqueTicPerAudioTrackType
-> Maybe NielsenSourceWatermarkStatusType
-> NielsenNonLinearWatermarkSettings
NielsenNonLinearWatermarkSettings'
    { $sel:episodeId:NielsenNonLinearWatermarkSettings' :: Maybe Text
episodeId =
        Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:activeWatermarkProcess:NielsenNonLinearWatermarkSettings' :: Maybe NielsenActiveWatermarkProcessType
activeWatermarkProcess = Maybe NielsenActiveWatermarkProcessType
forall a. Maybe a
Prelude.Nothing,
      $sel:sourceId:NielsenNonLinearWatermarkSettings' :: Maybe Natural
sourceId = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:cbetSourceId:NielsenNonLinearWatermarkSettings' :: Maybe Text
cbetSourceId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:ticServerUrl:NielsenNonLinearWatermarkSettings' :: Maybe Text
ticServerUrl = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:metadataDestination:NielsenNonLinearWatermarkSettings' :: Maybe Text
metadataDestination = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:assetName:NielsenNonLinearWatermarkSettings' :: Maybe Text
assetName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:adiFilename:NielsenNonLinearWatermarkSettings' :: Maybe Text
adiFilename = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:assetId:NielsenNonLinearWatermarkSettings' :: Maybe Text
assetId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:uniqueTicPerAudioTrack:NielsenNonLinearWatermarkSettings' :: Maybe NielsenUniqueTicPerAudioTrackType
uniqueTicPerAudioTrack = Maybe NielsenUniqueTicPerAudioTrackType
forall a. Maybe a
Prelude.Nothing,
      $sel:sourceWatermarkStatus:NielsenNonLinearWatermarkSettings' :: Maybe NielsenSourceWatermarkStatusType
sourceWatermarkStatus = Maybe NielsenSourceWatermarkStatusType
forall a. Maybe a
Prelude.Nothing
    }

-- | Optional. If this asset uses an episode ID with Nielsen, provide it
-- here.
nielsenNonLinearWatermarkSettings_episodeId :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe Prelude.Text)
nielsenNonLinearWatermarkSettings_episodeId :: (Maybe Text -> f (Maybe Text))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_episodeId = (NielsenNonLinearWatermarkSettings -> Maybe Text)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe Text -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe Text
episodeId :: Maybe Text
$sel:episodeId:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
episodeId} -> Maybe Text
episodeId) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe Text
a -> NielsenNonLinearWatermarkSettings
s {$sel:episodeId:NielsenNonLinearWatermarkSettings' :: Maybe Text
episodeId = Maybe Text
a} :: NielsenNonLinearWatermarkSettings)

-- | Choose the type of Nielsen watermarks that you want in your outputs.
-- When you choose NAES 2 and NW (NAES2_AND_NW), you must provide a value
-- for the setting SID (sourceId). When you choose CBET (CBET), you must
-- provide a value for the setting CSID (cbetSourceId). When you choose
-- NAES 2, NW, and CBET (NAES2_AND_NW_AND_CBET), you must provide values
-- for both of these settings.
nielsenNonLinearWatermarkSettings_activeWatermarkProcess :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe NielsenActiveWatermarkProcessType)
nielsenNonLinearWatermarkSettings_activeWatermarkProcess :: (Maybe NielsenActiveWatermarkProcessType
 -> f (Maybe NielsenActiveWatermarkProcessType))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_activeWatermarkProcess = (NielsenNonLinearWatermarkSettings
 -> Maybe NielsenActiveWatermarkProcessType)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe NielsenActiveWatermarkProcessType
    -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe NielsenActiveWatermarkProcessType)
     (Maybe NielsenActiveWatermarkProcessType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe NielsenActiveWatermarkProcessType
activeWatermarkProcess :: Maybe NielsenActiveWatermarkProcessType
$sel:activeWatermarkProcess:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings
-> Maybe NielsenActiveWatermarkProcessType
activeWatermarkProcess} -> Maybe NielsenActiveWatermarkProcessType
activeWatermarkProcess) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe NielsenActiveWatermarkProcessType
a -> NielsenNonLinearWatermarkSettings
s {$sel:activeWatermarkProcess:NielsenNonLinearWatermarkSettings' :: Maybe NielsenActiveWatermarkProcessType
activeWatermarkProcess = Maybe NielsenActiveWatermarkProcessType
a} :: NielsenNonLinearWatermarkSettings)

-- | Use the SID that Nielsen provides to you. This source ID should be
-- unique to your Nielsen account but common to all of your output assets.
-- Required for all Nielsen non-linear watermarking. This ID should be
-- unique to your Nielsen account but common to all of your output assets.
-- Required for all Nielsen non-linear watermarking.
nielsenNonLinearWatermarkSettings_sourceId :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe Prelude.Natural)
nielsenNonLinearWatermarkSettings_sourceId :: (Maybe Natural -> f (Maybe Natural))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_sourceId = (NielsenNonLinearWatermarkSettings -> Maybe Natural)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe Natural -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe Natural
sourceId :: Maybe Natural
$sel:sourceId:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Natural
sourceId} -> Maybe Natural
sourceId) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe Natural
a -> NielsenNonLinearWatermarkSettings
s {$sel:sourceId:NielsenNonLinearWatermarkSettings' :: Maybe Natural
sourceId = Maybe Natural
a} :: NielsenNonLinearWatermarkSettings)

-- | Use the CSID that Nielsen provides to you. This CBET source ID should be
-- unique to your Nielsen account but common to all of your output assets
-- that have CBET watermarking. Required when you choose a value for the
-- setting Watermark types (ActiveWatermarkProcess) that includes CBET.
nielsenNonLinearWatermarkSettings_cbetSourceId :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe Prelude.Text)
nielsenNonLinearWatermarkSettings_cbetSourceId :: (Maybe Text -> f (Maybe Text))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_cbetSourceId = (NielsenNonLinearWatermarkSettings -> Maybe Text)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe Text -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe Text
cbetSourceId :: Maybe Text
$sel:cbetSourceId:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
cbetSourceId} -> Maybe Text
cbetSourceId) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe Text
a -> NielsenNonLinearWatermarkSettings
s {$sel:cbetSourceId:NielsenNonLinearWatermarkSettings' :: Maybe Text
cbetSourceId = Maybe Text
a} :: NielsenNonLinearWatermarkSettings)

-- | Specify the endpoint for the TIC server that you have deployed and
-- configured in the AWS Cloud. Required for all Nielsen non-linear
-- watermarking. MediaConvert can\'t connect directly to a TIC server.
-- Instead, you must use API Gateway to provide a RESTful interface between
-- MediaConvert and a TIC server that you deploy in your AWS account. For
-- more information on deploying a TIC server in your AWS account and the
-- required API Gateway, contact Nielsen support.
nielsenNonLinearWatermarkSettings_ticServerUrl :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe Prelude.Text)
nielsenNonLinearWatermarkSettings_ticServerUrl :: (Maybe Text -> f (Maybe Text))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_ticServerUrl = (NielsenNonLinearWatermarkSettings -> Maybe Text)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe Text -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe Text
ticServerUrl :: Maybe Text
$sel:ticServerUrl:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
ticServerUrl} -> Maybe Text
ticServerUrl) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe Text
a -> NielsenNonLinearWatermarkSettings
s {$sel:ticServerUrl:NielsenNonLinearWatermarkSettings' :: Maybe Text
ticServerUrl = Maybe Text
a} :: NielsenNonLinearWatermarkSettings)

-- | Specify the Amazon S3 location where you want MediaConvert to save your
-- Nielsen non-linear metadata .zip file. This Amazon S3 bucket must be in
-- the same Region as the one where you do your MediaConvert transcoding.
-- If you want to include an ADI file in this .zip file, use the setting
-- ADI file (adiFilename) to specify it. MediaConvert delivers the Nielsen
-- metadata .zip files only to your metadata destination Amazon S3 bucket.
-- It doesn\'t deliver the .zip files to Nielsen. You are responsible for
-- delivering the metadata .zip files to Nielsen.
nielsenNonLinearWatermarkSettings_metadataDestination :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe Prelude.Text)
nielsenNonLinearWatermarkSettings_metadataDestination :: (Maybe Text -> f (Maybe Text))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_metadataDestination = (NielsenNonLinearWatermarkSettings -> Maybe Text)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe Text -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe Text
metadataDestination :: Maybe Text
$sel:metadataDestination:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
metadataDestination} -> Maybe Text
metadataDestination) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe Text
a -> NielsenNonLinearWatermarkSettings
s {$sel:metadataDestination:NielsenNonLinearWatermarkSettings' :: Maybe Text
metadataDestination = Maybe Text
a} :: NielsenNonLinearWatermarkSettings)

-- | Use the asset name that you provide to Nielsen for this asset. Required
-- for all Nielsen non-linear watermarking.
nielsenNonLinearWatermarkSettings_assetName :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe Prelude.Text)
nielsenNonLinearWatermarkSettings_assetName :: (Maybe Text -> f (Maybe Text))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_assetName = (NielsenNonLinearWatermarkSettings -> Maybe Text)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe Text -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe Text
assetName :: Maybe Text
$sel:assetName:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
assetName} -> Maybe Text
assetName) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe Text
a -> NielsenNonLinearWatermarkSettings
s {$sel:assetName:NielsenNonLinearWatermarkSettings' :: Maybe Text
assetName = Maybe Text
a} :: NielsenNonLinearWatermarkSettings)

-- | Optional. Use this setting when you want the service to include an ADI
-- file in the Nielsen metadata .zip file. To provide an ADI file, store it
-- in Amazon S3 and provide a URL to it here. The URL should be in the
-- following format: S3:\/\/bucket\/path\/ADI-file. For more information
-- about the metadata .zip file, see the setting Metadata destination
-- (metadataDestination).
nielsenNonLinearWatermarkSettings_adiFilename :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe Prelude.Text)
nielsenNonLinearWatermarkSettings_adiFilename :: (Maybe Text -> f (Maybe Text))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_adiFilename = (NielsenNonLinearWatermarkSettings -> Maybe Text)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe Text -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe Text
adiFilename :: Maybe Text
$sel:adiFilename:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
adiFilename} -> Maybe Text
adiFilename) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe Text
a -> NielsenNonLinearWatermarkSettings
s {$sel:adiFilename:NielsenNonLinearWatermarkSettings' :: Maybe Text
adiFilename = Maybe Text
a} :: NielsenNonLinearWatermarkSettings)

-- | Use the asset ID that you provide to Nielsen to uniquely identify this
-- asset. Required for all Nielsen non-linear watermarking.
nielsenNonLinearWatermarkSettings_assetId :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe Prelude.Text)
nielsenNonLinearWatermarkSettings_assetId :: (Maybe Text -> f (Maybe Text))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_assetId = (NielsenNonLinearWatermarkSettings -> Maybe Text)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe Text -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe Text
assetId :: Maybe Text
$sel:assetId:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
assetId} -> Maybe Text
assetId) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe Text
a -> NielsenNonLinearWatermarkSettings
s {$sel:assetId:NielsenNonLinearWatermarkSettings' :: Maybe Text
assetId = Maybe Text
a} :: NielsenNonLinearWatermarkSettings)

-- | To create assets that have the same TIC values in each audio track, keep
-- the default value Share TICs (SAME_TICS_PER_TRACK). To create assets
-- that have unique TIC values for each audio track, choose Use unique TICs
-- (RESERVE_UNIQUE_TICS_PER_TRACK).
nielsenNonLinearWatermarkSettings_uniqueTicPerAudioTrack :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe NielsenUniqueTicPerAudioTrackType)
nielsenNonLinearWatermarkSettings_uniqueTicPerAudioTrack :: (Maybe NielsenUniqueTicPerAudioTrackType
 -> f (Maybe NielsenUniqueTicPerAudioTrackType))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_uniqueTicPerAudioTrack = (NielsenNonLinearWatermarkSettings
 -> Maybe NielsenUniqueTicPerAudioTrackType)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe NielsenUniqueTicPerAudioTrackType
    -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe NielsenUniqueTicPerAudioTrackType)
     (Maybe NielsenUniqueTicPerAudioTrackType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe NielsenUniqueTicPerAudioTrackType
uniqueTicPerAudioTrack :: Maybe NielsenUniqueTicPerAudioTrackType
$sel:uniqueTicPerAudioTrack:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings
-> Maybe NielsenUniqueTicPerAudioTrackType
uniqueTicPerAudioTrack} -> Maybe NielsenUniqueTicPerAudioTrackType
uniqueTicPerAudioTrack) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe NielsenUniqueTicPerAudioTrackType
a -> NielsenNonLinearWatermarkSettings
s {$sel:uniqueTicPerAudioTrack:NielsenNonLinearWatermarkSettings' :: Maybe NielsenUniqueTicPerAudioTrackType
uniqueTicPerAudioTrack = Maybe NielsenUniqueTicPerAudioTrackType
a} :: NielsenNonLinearWatermarkSettings)

-- | Required. Specify whether your source content already contains Nielsen
-- non-linear watermarks. When you set this value to Watermarked
-- (WATERMARKED), the service fails the job. Nielsen requires that you add
-- non-linear watermarking to only clean content that doesn\'t already have
-- non-linear Nielsen watermarks.
nielsenNonLinearWatermarkSettings_sourceWatermarkStatus :: Lens.Lens' NielsenNonLinearWatermarkSettings (Prelude.Maybe NielsenSourceWatermarkStatusType)
nielsenNonLinearWatermarkSettings_sourceWatermarkStatus :: (Maybe NielsenSourceWatermarkStatusType
 -> f (Maybe NielsenSourceWatermarkStatusType))
-> NielsenNonLinearWatermarkSettings
-> f NielsenNonLinearWatermarkSettings
nielsenNonLinearWatermarkSettings_sourceWatermarkStatus = (NielsenNonLinearWatermarkSettings
 -> Maybe NielsenSourceWatermarkStatusType)
-> (NielsenNonLinearWatermarkSettings
    -> Maybe NielsenSourceWatermarkStatusType
    -> NielsenNonLinearWatermarkSettings)
-> Lens
     NielsenNonLinearWatermarkSettings
     NielsenNonLinearWatermarkSettings
     (Maybe NielsenSourceWatermarkStatusType)
     (Maybe NielsenSourceWatermarkStatusType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NielsenNonLinearWatermarkSettings' {Maybe NielsenSourceWatermarkStatusType
sourceWatermarkStatus :: Maybe NielsenSourceWatermarkStatusType
$sel:sourceWatermarkStatus:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings
-> Maybe NielsenSourceWatermarkStatusType
sourceWatermarkStatus} -> Maybe NielsenSourceWatermarkStatusType
sourceWatermarkStatus) (\s :: NielsenNonLinearWatermarkSettings
s@NielsenNonLinearWatermarkSettings' {} Maybe NielsenSourceWatermarkStatusType
a -> NielsenNonLinearWatermarkSettings
s {$sel:sourceWatermarkStatus:NielsenNonLinearWatermarkSettings' :: Maybe NielsenSourceWatermarkStatusType
sourceWatermarkStatus = Maybe NielsenSourceWatermarkStatusType
a} :: NielsenNonLinearWatermarkSettings)

instance
  Core.FromJSON
    NielsenNonLinearWatermarkSettings
  where
  parseJSON :: Value -> Parser NielsenNonLinearWatermarkSettings
parseJSON =
    String
-> (Object -> Parser NielsenNonLinearWatermarkSettings)
-> Value
-> Parser NielsenNonLinearWatermarkSettings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"NielsenNonLinearWatermarkSettings"
      ( \Object
x ->
          Maybe Text
-> Maybe NielsenActiveWatermarkProcessType
-> Maybe Natural
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe NielsenUniqueTicPerAudioTrackType
-> Maybe NielsenSourceWatermarkStatusType
-> NielsenNonLinearWatermarkSettings
NielsenNonLinearWatermarkSettings'
            (Maybe Text
 -> Maybe NielsenActiveWatermarkProcessType
 -> Maybe Natural
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe NielsenUniqueTicPerAudioTrackType
 -> Maybe NielsenSourceWatermarkStatusType
 -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe Text)
-> Parser
     (Maybe NielsenActiveWatermarkProcessType
      -> Maybe Natural
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe NielsenUniqueTicPerAudioTrackType
      -> Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
forall (f :: * -> *) a b. Functor 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
"episodeId")
            Parser
  (Maybe NielsenActiveWatermarkProcessType
   -> Maybe Natural
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe NielsenUniqueTicPerAudioTrackType
   -> Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe NielsenActiveWatermarkProcessType)
-> Parser
     (Maybe Natural
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe NielsenUniqueTicPerAudioTrackType
      -> Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe NielsenActiveWatermarkProcessType)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"activeWatermarkProcess")
            Parser
  (Maybe Natural
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe NielsenUniqueTicPerAudioTrackType
   -> Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe NielsenUniqueTicPerAudioTrackType
      -> Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
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
"sourceId")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe NielsenUniqueTicPerAudioTrackType
   -> Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe NielsenUniqueTicPerAudioTrackType
      -> Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
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
"cbetSourceId")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe NielsenUniqueTicPerAudioTrackType
   -> Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe NielsenUniqueTicPerAudioTrackType
      -> Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
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
"ticServerUrl")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe NielsenUniqueTicPerAudioTrackType
   -> Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe NielsenUniqueTicPerAudioTrackType
      -> Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
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
"metadataDestination")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe NielsenUniqueTicPerAudioTrackType
   -> Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe NielsenUniqueTicPerAudioTrackType
      -> Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
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
"assetName")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe NielsenUniqueTicPerAudioTrackType
   -> Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe NielsenUniqueTicPerAudioTrackType
      -> Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
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
"adiFilename")
            Parser
  (Maybe Text
   -> Maybe NielsenUniqueTicPerAudioTrackType
   -> Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe Text)
-> Parser
     (Maybe NielsenUniqueTicPerAudioTrackType
      -> Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
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
"assetId")
            Parser
  (Maybe NielsenUniqueTicPerAudioTrackType
   -> Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe NielsenUniqueTicPerAudioTrackType)
-> Parser
     (Maybe NielsenSourceWatermarkStatusType
      -> NielsenNonLinearWatermarkSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe NielsenUniqueTicPerAudioTrackType)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"uniqueTicPerAudioTrack")
            Parser
  (Maybe NielsenSourceWatermarkStatusType
   -> NielsenNonLinearWatermarkSettings)
-> Parser (Maybe NielsenSourceWatermarkStatusType)
-> Parser NielsenNonLinearWatermarkSettings
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe NielsenSourceWatermarkStatusType)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"sourceWatermarkStatus")
      )

instance
  Prelude.Hashable
    NielsenNonLinearWatermarkSettings

instance
  Prelude.NFData
    NielsenNonLinearWatermarkSettings

instance
  Core.ToJSON
    NielsenNonLinearWatermarkSettings
  where
  toJSON :: NielsenNonLinearWatermarkSettings -> Value
toJSON NielsenNonLinearWatermarkSettings' {Maybe Natural
Maybe Text
Maybe NielsenActiveWatermarkProcessType
Maybe NielsenSourceWatermarkStatusType
Maybe NielsenUniqueTicPerAudioTrackType
sourceWatermarkStatus :: Maybe NielsenSourceWatermarkStatusType
uniqueTicPerAudioTrack :: Maybe NielsenUniqueTicPerAudioTrackType
assetId :: Maybe Text
adiFilename :: Maybe Text
assetName :: Maybe Text
metadataDestination :: Maybe Text
ticServerUrl :: Maybe Text
cbetSourceId :: Maybe Text
sourceId :: Maybe Natural
activeWatermarkProcess :: Maybe NielsenActiveWatermarkProcessType
episodeId :: Maybe Text
$sel:sourceWatermarkStatus:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings
-> Maybe NielsenSourceWatermarkStatusType
$sel:uniqueTicPerAudioTrack:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings
-> Maybe NielsenUniqueTicPerAudioTrackType
$sel:assetId:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
$sel:adiFilename:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
$sel:assetName:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
$sel:metadataDestination:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
$sel:ticServerUrl:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
$sel:cbetSourceId:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
$sel:sourceId:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Natural
$sel:activeWatermarkProcess:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings
-> Maybe NielsenActiveWatermarkProcessType
$sel:episodeId:NielsenNonLinearWatermarkSettings' :: NielsenNonLinearWatermarkSettings -> Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"episodeId" 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
episodeId,
            (Text
"activeWatermarkProcess" Text -> NielsenActiveWatermarkProcessType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (NielsenActiveWatermarkProcessType -> Pair)
-> Maybe NielsenActiveWatermarkProcessType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe NielsenActiveWatermarkProcessType
activeWatermarkProcess,
            (Text
"sourceId" 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
sourceId,
            (Text
"cbetSourceId" 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
cbetSourceId,
            (Text
"ticServerUrl" 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
ticServerUrl,
            (Text
"metadataDestination" 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
metadataDestination,
            (Text
"assetName" 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
assetName,
            (Text
"adiFilename" 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
adiFilename,
            (Text
"assetId" 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
assetId,
            (Text
"uniqueTicPerAudioTrack" Text -> NielsenUniqueTicPerAudioTrackType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (NielsenUniqueTicPerAudioTrackType -> Pair)
-> Maybe NielsenUniqueTicPerAudioTrackType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe NielsenUniqueTicPerAudioTrackType
uniqueTicPerAudioTrack,
            (Text
"sourceWatermarkStatus" Text -> NielsenSourceWatermarkStatusType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (NielsenSourceWatermarkStatusType -> Pair)
-> Maybe NielsenSourceWatermarkStatusType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe NielsenSourceWatermarkStatusType
sourceWatermarkStatus
          ]
      )