{-# 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.InputRotate
-- 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.InputRotate
  ( InputRotate
      ( ..,
        InputRotate_AUTO,
        InputRotate_DEGREES_180,
        InputRotate_DEGREES_270,
        InputRotate_DEGREES_90,
        InputRotate_DEGREE_0
      ),
  )
where

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

-- | Use Rotate (InputRotate) to specify how the service rotates your video.
-- You can choose automatic rotation or specify a rotation. You can specify
-- a clockwise rotation of 0, 90, 180, or 270 degrees. If your input video
-- container is .mov or .mp4 and your input has rotation metadata, you can
-- choose Automatic to have the service rotate your video according to the
-- rotation specified in the metadata. The rotation must be within one
-- degree of 90, 180, or 270 degrees. If the rotation metadata specifies
-- any other rotation, the service will default to no rotation. By default,
-- the service does no rotation, even if your input video has rotation
-- metadata. The service doesn\'t pass through rotation metadata.
newtype InputRotate = InputRotate'
  { InputRotate -> Text
fromInputRotate ::
      Core.Text
  }
  deriving stock
    ( Int -> InputRotate -> ShowS
[InputRotate] -> ShowS
InputRotate -> String
(Int -> InputRotate -> ShowS)
-> (InputRotate -> String)
-> ([InputRotate] -> ShowS)
-> Show InputRotate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputRotate] -> ShowS
$cshowList :: [InputRotate] -> ShowS
show :: InputRotate -> String
$cshow :: InputRotate -> String
showsPrec :: Int -> InputRotate -> ShowS
$cshowsPrec :: Int -> InputRotate -> ShowS
Prelude.Show,
      ReadPrec [InputRotate]
ReadPrec InputRotate
Int -> ReadS InputRotate
ReadS [InputRotate]
(Int -> ReadS InputRotate)
-> ReadS [InputRotate]
-> ReadPrec InputRotate
-> ReadPrec [InputRotate]
-> Read InputRotate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InputRotate]
$creadListPrec :: ReadPrec [InputRotate]
readPrec :: ReadPrec InputRotate
$creadPrec :: ReadPrec InputRotate
readList :: ReadS [InputRotate]
$creadList :: ReadS [InputRotate]
readsPrec :: Int -> ReadS InputRotate
$creadsPrec :: Int -> ReadS InputRotate
Prelude.Read,
      InputRotate -> InputRotate -> Bool
(InputRotate -> InputRotate -> Bool)
-> (InputRotate -> InputRotate -> Bool) -> Eq InputRotate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputRotate -> InputRotate -> Bool
$c/= :: InputRotate -> InputRotate -> Bool
== :: InputRotate -> InputRotate -> Bool
$c== :: InputRotate -> InputRotate -> Bool
Prelude.Eq,
      Eq InputRotate
Eq InputRotate
-> (InputRotate -> InputRotate -> Ordering)
-> (InputRotate -> InputRotate -> Bool)
-> (InputRotate -> InputRotate -> Bool)
-> (InputRotate -> InputRotate -> Bool)
-> (InputRotate -> InputRotate -> Bool)
-> (InputRotate -> InputRotate -> InputRotate)
-> (InputRotate -> InputRotate -> InputRotate)
-> Ord InputRotate
InputRotate -> InputRotate -> Bool
InputRotate -> InputRotate -> Ordering
InputRotate -> InputRotate -> InputRotate
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 :: InputRotate -> InputRotate -> InputRotate
$cmin :: InputRotate -> InputRotate -> InputRotate
max :: InputRotate -> InputRotate -> InputRotate
$cmax :: InputRotate -> InputRotate -> InputRotate
>= :: InputRotate -> InputRotate -> Bool
$c>= :: InputRotate -> InputRotate -> Bool
> :: InputRotate -> InputRotate -> Bool
$c> :: InputRotate -> InputRotate -> Bool
<= :: InputRotate -> InputRotate -> Bool
$c<= :: InputRotate -> InputRotate -> Bool
< :: InputRotate -> InputRotate -> Bool
$c< :: InputRotate -> InputRotate -> Bool
compare :: InputRotate -> InputRotate -> Ordering
$ccompare :: InputRotate -> InputRotate -> Ordering
$cp1Ord :: Eq InputRotate
Prelude.Ord,
      (forall x. InputRotate -> Rep InputRotate x)
-> (forall x. Rep InputRotate x -> InputRotate)
-> Generic InputRotate
forall x. Rep InputRotate x -> InputRotate
forall x. InputRotate -> Rep InputRotate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InputRotate x -> InputRotate
$cfrom :: forall x. InputRotate -> Rep InputRotate x
Prelude.Generic
    )
  deriving newtype
    ( Int -> InputRotate -> Int
InputRotate -> Int
(Int -> InputRotate -> Int)
-> (InputRotate -> Int) -> Hashable InputRotate
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: InputRotate -> Int
$chash :: InputRotate -> Int
hashWithSalt :: Int -> InputRotate -> Int
$chashWithSalt :: Int -> InputRotate -> Int
Prelude.Hashable,
      InputRotate -> ()
(InputRotate -> ()) -> NFData InputRotate
forall a. (a -> ()) -> NFData a
rnf :: InputRotate -> ()
$crnf :: InputRotate -> ()
Prelude.NFData,
      Text -> Either String InputRotate
(Text -> Either String InputRotate) -> FromText InputRotate
forall a. (Text -> Either String a) -> FromText a
fromText :: Text -> Either String InputRotate
$cfromText :: Text -> Either String InputRotate
Core.FromText,
      InputRotate -> Text
(InputRotate -> Text) -> ToText InputRotate
forall a. (a -> Text) -> ToText a
toText :: InputRotate -> Text
$ctoText :: InputRotate -> Text
Core.ToText,
      InputRotate -> ByteString
(InputRotate -> ByteString) -> ToByteString InputRotate
forall a. (a -> ByteString) -> ToByteString a
toBS :: InputRotate -> ByteString
$ctoBS :: InputRotate -> ByteString
Core.ToByteString,
      InputRotate -> ByteStringBuilder
(InputRotate -> ByteStringBuilder) -> ToLog InputRotate
forall a. (a -> ByteStringBuilder) -> ToLog a
build :: InputRotate -> ByteStringBuilder
$cbuild :: InputRotate -> ByteStringBuilder
Core.ToLog,
      HeaderName -> InputRotate -> [Header]
(HeaderName -> InputRotate -> [Header]) -> ToHeader InputRotate
forall a. (HeaderName -> a -> [Header]) -> ToHeader a
toHeader :: HeaderName -> InputRotate -> [Header]
$ctoHeader :: HeaderName -> InputRotate -> [Header]
Core.ToHeader,
      InputRotate -> QueryString
(InputRotate -> QueryString) -> ToQuery InputRotate
forall a. (a -> QueryString) -> ToQuery a
toQuery :: InputRotate -> QueryString
$ctoQuery :: InputRotate -> QueryString
Core.ToQuery,
      Value -> Parser [InputRotate]
Value -> Parser InputRotate
(Value -> Parser InputRotate)
-> (Value -> Parser [InputRotate]) -> FromJSON InputRotate
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [InputRotate]
$cparseJSONList :: Value -> Parser [InputRotate]
parseJSON :: Value -> Parser InputRotate
$cparseJSON :: Value -> Parser InputRotate
Core.FromJSON,
      FromJSONKeyFunction [InputRotate]
FromJSONKeyFunction InputRotate
FromJSONKeyFunction InputRotate
-> FromJSONKeyFunction [InputRotate] -> FromJSONKey InputRotate
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [InputRotate]
$cfromJSONKeyList :: FromJSONKeyFunction [InputRotate]
fromJSONKey :: FromJSONKeyFunction InputRotate
$cfromJSONKey :: FromJSONKeyFunction InputRotate
Core.FromJSONKey,
      [InputRotate] -> Encoding
[InputRotate] -> Value
InputRotate -> Encoding
InputRotate -> Value
(InputRotate -> Value)
-> (InputRotate -> Encoding)
-> ([InputRotate] -> Value)
-> ([InputRotate] -> Encoding)
-> ToJSON InputRotate
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [InputRotate] -> Encoding
$ctoEncodingList :: [InputRotate] -> Encoding
toJSONList :: [InputRotate] -> Value
$ctoJSONList :: [InputRotate] -> Value
toEncoding :: InputRotate -> Encoding
$ctoEncoding :: InputRotate -> Encoding
toJSON :: InputRotate -> Value
$ctoJSON :: InputRotate -> Value
Core.ToJSON,
      ToJSONKeyFunction [InputRotate]
ToJSONKeyFunction InputRotate
ToJSONKeyFunction InputRotate
-> ToJSONKeyFunction [InputRotate] -> ToJSONKey InputRotate
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [InputRotate]
$ctoJSONKeyList :: ToJSONKeyFunction [InputRotate]
toJSONKey :: ToJSONKeyFunction InputRotate
$ctoJSONKey :: ToJSONKeyFunction InputRotate
Core.ToJSONKey,
      [Node] -> Either String InputRotate
([Node] -> Either String InputRotate) -> FromXML InputRotate
forall a. ([Node] -> Either String a) -> FromXML a
parseXML :: [Node] -> Either String InputRotate
$cparseXML :: [Node] -> Either String InputRotate
Core.FromXML,
      InputRotate -> XML
(InputRotate -> XML) -> ToXML InputRotate
forall a. (a -> XML) -> ToXML a
toXML :: InputRotate -> XML
$ctoXML :: InputRotate -> XML
Core.ToXML
    )

pattern InputRotate_AUTO :: InputRotate
pattern $bInputRotate_AUTO :: InputRotate
$mInputRotate_AUTO :: forall r. InputRotate -> (Void# -> r) -> (Void# -> r) -> r
InputRotate_AUTO = InputRotate' "AUTO"

pattern InputRotate_DEGREES_180 :: InputRotate
pattern $bInputRotate_DEGREES_180 :: InputRotate
$mInputRotate_DEGREES_180 :: forall r. InputRotate -> (Void# -> r) -> (Void# -> r) -> r
InputRotate_DEGREES_180 = InputRotate' "DEGREES_180"

pattern InputRotate_DEGREES_270 :: InputRotate
pattern $bInputRotate_DEGREES_270 :: InputRotate
$mInputRotate_DEGREES_270 :: forall r. InputRotate -> (Void# -> r) -> (Void# -> r) -> r
InputRotate_DEGREES_270 = InputRotate' "DEGREES_270"

pattern InputRotate_DEGREES_90 :: InputRotate
pattern $bInputRotate_DEGREES_90 :: InputRotate
$mInputRotate_DEGREES_90 :: forall r. InputRotate -> (Void# -> r) -> (Void# -> r) -> r
InputRotate_DEGREES_90 = InputRotate' "DEGREES_90"

pattern InputRotate_DEGREE_0 :: InputRotate
pattern $bInputRotate_DEGREE_0 :: InputRotate
$mInputRotate_DEGREE_0 :: forall r. InputRotate -> (Void# -> r) -> (Void# -> r) -> r
InputRotate_DEGREE_0 = InputRotate' "DEGREE_0"

{-# COMPLETE
  InputRotate_AUTO,
  InputRotate_DEGREES_180,
  InputRotate_DEGREES_270,
  InputRotate_DEGREES_90,
  InputRotate_DEGREE_0,
  InputRotate'
  #-}