{-# 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.Inspector2.Types.FindingTypeSortBy
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Inspector2.Types.FindingTypeSortBy
  ( FindingTypeSortBy
      ( ..,
        FindingTypeSortBy_ALL,
        FindingTypeSortBy_CRITICAL,
        FindingTypeSortBy_HIGH
      ),
  )
where

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

newtype FindingTypeSortBy = FindingTypeSortBy'
  { FindingTypeSortBy -> Text
fromFindingTypeSortBy ::
      Data.Text
  }
  deriving stock
    ( Int -> FindingTypeSortBy -> ShowS
[FindingTypeSortBy] -> ShowS
FindingTypeSortBy -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FindingTypeSortBy] -> ShowS
$cshowList :: [FindingTypeSortBy] -> ShowS
show :: FindingTypeSortBy -> String
$cshow :: FindingTypeSortBy -> String
showsPrec :: Int -> FindingTypeSortBy -> ShowS
$cshowsPrec :: Int -> FindingTypeSortBy -> ShowS
Prelude.Show,
      ReadPrec [FindingTypeSortBy]
ReadPrec FindingTypeSortBy
Int -> ReadS FindingTypeSortBy
ReadS [FindingTypeSortBy]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FindingTypeSortBy]
$creadListPrec :: ReadPrec [FindingTypeSortBy]
readPrec :: ReadPrec FindingTypeSortBy
$creadPrec :: ReadPrec FindingTypeSortBy
readList :: ReadS [FindingTypeSortBy]
$creadList :: ReadS [FindingTypeSortBy]
readsPrec :: Int -> ReadS FindingTypeSortBy
$creadsPrec :: Int -> ReadS FindingTypeSortBy
Prelude.Read,
      FindingTypeSortBy -> FindingTypeSortBy -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
$c/= :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
== :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
$c== :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
Prelude.Eq,
      Eq FindingTypeSortBy
FindingTypeSortBy -> FindingTypeSortBy -> Bool
FindingTypeSortBy -> FindingTypeSortBy -> Ordering
FindingTypeSortBy -> FindingTypeSortBy -> FindingTypeSortBy
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 :: FindingTypeSortBy -> FindingTypeSortBy -> FindingTypeSortBy
$cmin :: FindingTypeSortBy -> FindingTypeSortBy -> FindingTypeSortBy
max :: FindingTypeSortBy -> FindingTypeSortBy -> FindingTypeSortBy
$cmax :: FindingTypeSortBy -> FindingTypeSortBy -> FindingTypeSortBy
>= :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
$c>= :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
> :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
$c> :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
<= :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
$c<= :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
< :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
$c< :: FindingTypeSortBy -> FindingTypeSortBy -> Bool
compare :: FindingTypeSortBy -> FindingTypeSortBy -> Ordering
$ccompare :: FindingTypeSortBy -> FindingTypeSortBy -> Ordering
Prelude.Ord,
      forall x. Rep FindingTypeSortBy x -> FindingTypeSortBy
forall x. FindingTypeSortBy -> Rep FindingTypeSortBy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FindingTypeSortBy x -> FindingTypeSortBy
$cfrom :: forall x. FindingTypeSortBy -> Rep FindingTypeSortBy x
Prelude.Generic
    )
  deriving newtype
    ( Eq FindingTypeSortBy
Int -> FindingTypeSortBy -> Int
FindingTypeSortBy -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: FindingTypeSortBy -> Int
$chash :: FindingTypeSortBy -> Int
hashWithSalt :: Int -> FindingTypeSortBy -> Int
$chashWithSalt :: Int -> FindingTypeSortBy -> Int
Prelude.Hashable,
      FindingTypeSortBy -> ()
forall a. (a -> ()) -> NFData a
rnf :: FindingTypeSortBy -> ()
$crnf :: FindingTypeSortBy -> ()
Prelude.NFData,
      Text -> Either String FindingTypeSortBy
forall a. (Text -> Either String a) -> FromText a
fromText :: Text -> Either String FindingTypeSortBy
$cfromText :: Text -> Either String FindingTypeSortBy
Data.FromText,
      FindingTypeSortBy -> Text
forall a. (a -> Text) -> ToText a
toText :: FindingTypeSortBy -> Text
$ctoText :: FindingTypeSortBy -> Text
Data.ToText,
      FindingTypeSortBy -> ByteString
forall a. (a -> ByteString) -> ToByteString a
toBS :: FindingTypeSortBy -> ByteString
$ctoBS :: FindingTypeSortBy -> ByteString
Data.ToByteString,
      FindingTypeSortBy -> ByteStringBuilder
forall a. (a -> ByteStringBuilder) -> ToLog a
build :: FindingTypeSortBy -> ByteStringBuilder
$cbuild :: FindingTypeSortBy -> ByteStringBuilder
Data.ToLog,
      HeaderName -> FindingTypeSortBy -> [Header]
forall a. (HeaderName -> a -> [Header]) -> ToHeader a
toHeader :: HeaderName -> FindingTypeSortBy -> [Header]
$ctoHeader :: HeaderName -> FindingTypeSortBy -> [Header]
Data.ToHeader,
      FindingTypeSortBy -> QueryString
forall a. (a -> QueryString) -> ToQuery a
toQuery :: FindingTypeSortBy -> QueryString
$ctoQuery :: FindingTypeSortBy -> QueryString
Data.ToQuery,
      Value -> Parser [FindingTypeSortBy]
Value -> Parser FindingTypeSortBy
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [FindingTypeSortBy]
$cparseJSONList :: Value -> Parser [FindingTypeSortBy]
parseJSON :: Value -> Parser FindingTypeSortBy
$cparseJSON :: Value -> Parser FindingTypeSortBy
Data.FromJSON,
      FromJSONKeyFunction [FindingTypeSortBy]
FromJSONKeyFunction FindingTypeSortBy
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [FindingTypeSortBy]
$cfromJSONKeyList :: FromJSONKeyFunction [FindingTypeSortBy]
fromJSONKey :: FromJSONKeyFunction FindingTypeSortBy
$cfromJSONKey :: FromJSONKeyFunction FindingTypeSortBy
Data.FromJSONKey,
      [FindingTypeSortBy] -> Encoding
[FindingTypeSortBy] -> Value
FindingTypeSortBy -> Encoding
FindingTypeSortBy -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [FindingTypeSortBy] -> Encoding
$ctoEncodingList :: [FindingTypeSortBy] -> Encoding
toJSONList :: [FindingTypeSortBy] -> Value
$ctoJSONList :: [FindingTypeSortBy] -> Value
toEncoding :: FindingTypeSortBy -> Encoding
$ctoEncoding :: FindingTypeSortBy -> Encoding
toJSON :: FindingTypeSortBy -> Value
$ctoJSON :: FindingTypeSortBy -> Value
Data.ToJSON,
      ToJSONKeyFunction [FindingTypeSortBy]
ToJSONKeyFunction FindingTypeSortBy
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [FindingTypeSortBy]
$ctoJSONKeyList :: ToJSONKeyFunction [FindingTypeSortBy]
toJSONKey :: ToJSONKeyFunction FindingTypeSortBy
$ctoJSONKey :: ToJSONKeyFunction FindingTypeSortBy
Data.ToJSONKey,
      [Node] -> Either String FindingTypeSortBy
forall a. ([Node] -> Either String a) -> FromXML a
parseXML :: [Node] -> Either String FindingTypeSortBy
$cparseXML :: [Node] -> Either String FindingTypeSortBy
Data.FromXML,
      FindingTypeSortBy -> XML
forall a. (a -> XML) -> ToXML a
toXML :: FindingTypeSortBy -> XML
$ctoXML :: FindingTypeSortBy -> XML
Data.ToXML
    )

pattern FindingTypeSortBy_ALL :: FindingTypeSortBy
pattern $bFindingTypeSortBy_ALL :: FindingTypeSortBy
$mFindingTypeSortBy_ALL :: forall {r}. FindingTypeSortBy -> ((# #) -> r) -> ((# #) -> r) -> r
FindingTypeSortBy_ALL = FindingTypeSortBy' "ALL"

pattern FindingTypeSortBy_CRITICAL :: FindingTypeSortBy
pattern $bFindingTypeSortBy_CRITICAL :: FindingTypeSortBy
$mFindingTypeSortBy_CRITICAL :: forall {r}. FindingTypeSortBy -> ((# #) -> r) -> ((# #) -> r) -> r
FindingTypeSortBy_CRITICAL = FindingTypeSortBy' "CRITICAL"

pattern FindingTypeSortBy_HIGH :: FindingTypeSortBy
pattern $bFindingTypeSortBy_HIGH :: FindingTypeSortBy
$mFindingTypeSortBy_HIGH :: forall {r}. FindingTypeSortBy -> ((# #) -> r) -> ((# #) -> r) -> r
FindingTypeSortBy_HIGH = FindingTypeSortBy' "HIGH"

{-# COMPLETE
  FindingTypeSortBy_ALL,
  FindingTypeSortBy_CRITICAL,
  FindingTypeSortBy_HIGH,
  FindingTypeSortBy'
  #-}