{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.MediaConvert.Types.RespondToAfd
-- 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.RespondToAfd
  ( RespondToAfd
      ( ..,
        RespondToAfd_NONE,
        RespondToAfd_PASSTHROUGH,
        RespondToAfd_RESPOND
      ),
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Prelude as Prelude

-- | Use Respond to AFD (RespondToAfd) to specify how the service changes the
-- video itself in response to AFD values in the input. * Choose Respond to
-- clip the input video frame according to the AFD value, input display
-- aspect ratio, and output display aspect ratio. * Choose Passthrough to
-- include the input AFD values. Do not choose this when AfdSignaling is
-- set to (NONE). A preferred implementation of this workflow is to set
-- RespondToAfd to (NONE) and set AfdSignaling to (AUTO). * Choose None to
-- remove all input AFD values from this output.
newtype RespondToAfd = RespondToAfd'
  { RespondToAfd -> Text
fromRespondToAfd ::
      Core.Text
  }
  deriving stock
    ( Int -> RespondToAfd -> ShowS
[RespondToAfd] -> ShowS
RespondToAfd -> String
(Int -> RespondToAfd -> ShowS)
-> (RespondToAfd -> String)
-> ([RespondToAfd] -> ShowS)
-> Show RespondToAfd
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RespondToAfd] -> ShowS
$cshowList :: [RespondToAfd] -> ShowS
show :: RespondToAfd -> String
$cshow :: RespondToAfd -> String
showsPrec :: Int -> RespondToAfd -> ShowS
$cshowsPrec :: Int -> RespondToAfd -> ShowS
Prelude.Show,
      ReadPrec [RespondToAfd]
ReadPrec RespondToAfd
Int -> ReadS RespondToAfd
ReadS [RespondToAfd]
(Int -> ReadS RespondToAfd)
-> ReadS [RespondToAfd]
-> ReadPrec RespondToAfd
-> ReadPrec [RespondToAfd]
-> Read RespondToAfd
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RespondToAfd]
$creadListPrec :: ReadPrec [RespondToAfd]
readPrec :: ReadPrec RespondToAfd
$creadPrec :: ReadPrec RespondToAfd
readList :: ReadS [RespondToAfd]
$creadList :: ReadS [RespondToAfd]
readsPrec :: Int -> ReadS RespondToAfd
$creadsPrec :: Int -> ReadS RespondToAfd
Prelude.Read,
      RespondToAfd -> RespondToAfd -> Bool
(RespondToAfd -> RespondToAfd -> Bool)
-> (RespondToAfd -> RespondToAfd -> Bool) -> Eq RespondToAfd
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RespondToAfd -> RespondToAfd -> Bool
$c/= :: RespondToAfd -> RespondToAfd -> Bool
== :: RespondToAfd -> RespondToAfd -> Bool
$c== :: RespondToAfd -> RespondToAfd -> Bool
Prelude.Eq,
      Eq RespondToAfd
Eq RespondToAfd
-> (RespondToAfd -> RespondToAfd -> Ordering)
-> (RespondToAfd -> RespondToAfd -> Bool)
-> (RespondToAfd -> RespondToAfd -> Bool)
-> (RespondToAfd -> RespondToAfd -> Bool)
-> (RespondToAfd -> RespondToAfd -> Bool)
-> (RespondToAfd -> RespondToAfd -> RespondToAfd)
-> (RespondToAfd -> RespondToAfd -> RespondToAfd)
-> Ord RespondToAfd
RespondToAfd -> RespondToAfd -> Bool
RespondToAfd -> RespondToAfd -> Ordering
RespondToAfd -> RespondToAfd -> RespondToAfd
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RespondToAfd -> RespondToAfd -> RespondToAfd
$cmin :: RespondToAfd -> RespondToAfd -> RespondToAfd
max :: RespondToAfd -> RespondToAfd -> RespondToAfd
$cmax :: RespondToAfd -> RespondToAfd -> RespondToAfd
>= :: RespondToAfd -> RespondToAfd -> Bool
$c>= :: RespondToAfd -> RespondToAfd -> Bool
> :: RespondToAfd -> RespondToAfd -> Bool
$c> :: RespondToAfd -> RespondToAfd -> Bool
<= :: RespondToAfd -> RespondToAfd -> Bool
$c<= :: RespondToAfd -> RespondToAfd -> Bool
< :: RespondToAfd -> RespondToAfd -> Bool
$c< :: RespondToAfd -> RespondToAfd -> Bool
compare :: RespondToAfd -> RespondToAfd -> Ordering
$ccompare :: RespondToAfd -> RespondToAfd -> Ordering
$cp1Ord :: Eq RespondToAfd
Prelude.Ord,
      (forall x. RespondToAfd -> Rep RespondToAfd x)
-> (forall x. Rep RespondToAfd x -> RespondToAfd)
-> Generic RespondToAfd
forall x. Rep RespondToAfd x -> RespondToAfd
forall x. RespondToAfd -> Rep RespondToAfd x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RespondToAfd x -> RespondToAfd
$cfrom :: forall x. RespondToAfd -> Rep RespondToAfd x
Prelude.Generic
    )
  deriving newtype
    ( Int -> RespondToAfd -> Int
RespondToAfd -> Int
(Int -> RespondToAfd -> Int)
-> (RespondToAfd -> Int) -> Hashable RespondToAfd
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: RespondToAfd -> Int
$chash :: RespondToAfd -> Int
hashWithSalt :: Int -> RespondToAfd -> Int
$chashWithSalt :: Int -> RespondToAfd -> Int
Prelude.Hashable,
      RespondToAfd -> ()
(RespondToAfd -> ()) -> NFData RespondToAfd
forall a. (a -> ()) -> NFData a
rnf :: RespondToAfd -> ()
$crnf :: RespondToAfd -> ()
Prelude.NFData,
      Text -> Either String RespondToAfd
(Text -> Either String RespondToAfd) -> FromText RespondToAfd
forall a. (Text -> Either String a) -> FromText a
fromText :: Text -> Either String RespondToAfd
$cfromText :: Text -> Either String RespondToAfd
Core.FromText,
      RespondToAfd -> Text
(RespondToAfd -> Text) -> ToText RespondToAfd
forall a. (a -> Text) -> ToText a
toText :: RespondToAfd -> Text
$ctoText :: RespondToAfd -> Text
Core.ToText,
      RespondToAfd -> ByteString
(RespondToAfd -> ByteString) -> ToByteString RespondToAfd
forall a. (a -> ByteString) -> ToByteString a
toBS :: RespondToAfd -> ByteString
$ctoBS :: RespondToAfd -> ByteString
Core.ToByteString,
      RespondToAfd -> ByteStringBuilder
(RespondToAfd -> ByteStringBuilder) -> ToLog RespondToAfd
forall a. (a -> ByteStringBuilder) -> ToLog a
build :: RespondToAfd -> ByteStringBuilder
$cbuild :: RespondToAfd -> ByteStringBuilder
Core.ToLog,
      HeaderName -> RespondToAfd -> [Header]
(HeaderName -> RespondToAfd -> [Header]) -> ToHeader RespondToAfd
forall a. (HeaderName -> a -> [Header]) -> ToHeader a
toHeader :: HeaderName -> RespondToAfd -> [Header]
$ctoHeader :: HeaderName -> RespondToAfd -> [Header]
Core.ToHeader,
      RespondToAfd -> QueryString
(RespondToAfd -> QueryString) -> ToQuery RespondToAfd
forall a. (a -> QueryString) -> ToQuery a
toQuery :: RespondToAfd -> QueryString
$ctoQuery :: RespondToAfd -> QueryString
Core.ToQuery,
      Value -> Parser [RespondToAfd]
Value -> Parser RespondToAfd
(Value -> Parser RespondToAfd)
-> (Value -> Parser [RespondToAfd]) -> FromJSON RespondToAfd
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [RespondToAfd]
$cparseJSONList :: Value -> Parser [RespondToAfd]
parseJSON :: Value -> Parser RespondToAfd
$cparseJSON :: Value -> Parser RespondToAfd
Core.FromJSON,
      FromJSONKeyFunction [RespondToAfd]
FromJSONKeyFunction RespondToAfd
FromJSONKeyFunction RespondToAfd
-> FromJSONKeyFunction [RespondToAfd] -> FromJSONKey RespondToAfd
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [RespondToAfd]
$cfromJSONKeyList :: FromJSONKeyFunction [RespondToAfd]
fromJSONKey :: FromJSONKeyFunction RespondToAfd
$cfromJSONKey :: FromJSONKeyFunction RespondToAfd
Core.FromJSONKey,
      [RespondToAfd] -> Encoding
[RespondToAfd] -> Value
RespondToAfd -> Encoding
RespondToAfd -> Value
(RespondToAfd -> Value)
-> (RespondToAfd -> Encoding)
-> ([RespondToAfd] -> Value)
-> ([RespondToAfd] -> Encoding)
-> ToJSON RespondToAfd
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [RespondToAfd] -> Encoding
$ctoEncodingList :: [RespondToAfd] -> Encoding
toJSONList :: [RespondToAfd] -> Value
$ctoJSONList :: [RespondToAfd] -> Value
toEncoding :: RespondToAfd -> Encoding
$ctoEncoding :: RespondToAfd -> Encoding
toJSON :: RespondToAfd -> Value
$ctoJSON :: RespondToAfd -> Value
Core.ToJSON,
      ToJSONKeyFunction [RespondToAfd]
ToJSONKeyFunction RespondToAfd
ToJSONKeyFunction RespondToAfd
-> ToJSONKeyFunction [RespondToAfd] -> ToJSONKey RespondToAfd
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [RespondToAfd]
$ctoJSONKeyList :: ToJSONKeyFunction [RespondToAfd]
toJSONKey :: ToJSONKeyFunction RespondToAfd
$ctoJSONKey :: ToJSONKeyFunction RespondToAfd
Core.ToJSONKey,
      [Node] -> Either String RespondToAfd
([Node] -> Either String RespondToAfd) -> FromXML RespondToAfd
forall a. ([Node] -> Either String a) -> FromXML a
parseXML :: [Node] -> Either String RespondToAfd
$cparseXML :: [Node] -> Either String RespondToAfd
Core.FromXML,
      RespondToAfd -> XML
(RespondToAfd -> XML) -> ToXML RespondToAfd
forall a. (a -> XML) -> ToXML a
toXML :: RespondToAfd -> XML
$ctoXML :: RespondToAfd -> XML
Core.ToXML
    )

pattern RespondToAfd_NONE :: RespondToAfd
pattern $bRespondToAfd_NONE :: RespondToAfd
$mRespondToAfd_NONE :: forall r. RespondToAfd -> (Void# -> r) -> (Void# -> r) -> r
RespondToAfd_NONE = RespondToAfd' "NONE"

pattern RespondToAfd_PASSTHROUGH :: RespondToAfd
pattern $bRespondToAfd_PASSTHROUGH :: RespondToAfd
$mRespondToAfd_PASSTHROUGH :: forall r. RespondToAfd -> (Void# -> r) -> (Void# -> r) -> r
RespondToAfd_PASSTHROUGH = RespondToAfd' "PASSTHROUGH"

pattern RespondToAfd_RESPOND :: RespondToAfd
pattern $bRespondToAfd_RESPOND :: RespondToAfd
$mRespondToAfd_RESPOND :: forall r. RespondToAfd -> (Void# -> r) -> (Void# -> r) -> r
RespondToAfd_RESPOND = RespondToAfd' "RESPOND"

{-# COMPLETE
  RespondToAfd_NONE,
  RespondToAfd_PASSTHROUGH,
  RespondToAfd_RESPOND,
  RespondToAfd'
  #-}