{-# 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.NetworkFirewall.Types.TCPFlag
-- 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.NetworkFirewall.Types.TCPFlag
  ( TCPFlag
      ( ..,
        TCPFlag_ACK,
        TCPFlag_CWR,
        TCPFlag_ECE,
        TCPFlag_FIN,
        TCPFlag_PSH,
        TCPFlag_RST,
        TCPFlag_SYN,
        TCPFlag_URG
      ),
  )
where

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

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

pattern TCPFlag_ACK :: TCPFlag
pattern $bTCPFlag_ACK :: TCPFlag
$mTCPFlag_ACK :: forall {r}. TCPFlag -> ((# #) -> r) -> ((# #) -> r) -> r
TCPFlag_ACK = TCPFlag' "ACK"

pattern TCPFlag_CWR :: TCPFlag
pattern $bTCPFlag_CWR :: TCPFlag
$mTCPFlag_CWR :: forall {r}. TCPFlag -> ((# #) -> r) -> ((# #) -> r) -> r
TCPFlag_CWR = TCPFlag' "CWR"

pattern TCPFlag_ECE :: TCPFlag
pattern $bTCPFlag_ECE :: TCPFlag
$mTCPFlag_ECE :: forall {r}. TCPFlag -> ((# #) -> r) -> ((# #) -> r) -> r
TCPFlag_ECE = TCPFlag' "ECE"

pattern TCPFlag_FIN :: TCPFlag
pattern $bTCPFlag_FIN :: TCPFlag
$mTCPFlag_FIN :: forall {r}. TCPFlag -> ((# #) -> r) -> ((# #) -> r) -> r
TCPFlag_FIN = TCPFlag' "FIN"

pattern TCPFlag_PSH :: TCPFlag
pattern $bTCPFlag_PSH :: TCPFlag
$mTCPFlag_PSH :: forall {r}. TCPFlag -> ((# #) -> r) -> ((# #) -> r) -> r
TCPFlag_PSH = TCPFlag' "PSH"

pattern TCPFlag_RST :: TCPFlag
pattern $bTCPFlag_RST :: TCPFlag
$mTCPFlag_RST :: forall {r}. TCPFlag -> ((# #) -> r) -> ((# #) -> r) -> r
TCPFlag_RST = TCPFlag' "RST"

pattern TCPFlag_SYN :: TCPFlag
pattern $bTCPFlag_SYN :: TCPFlag
$mTCPFlag_SYN :: forall {r}. TCPFlag -> ((# #) -> r) -> ((# #) -> r) -> r
TCPFlag_SYN = TCPFlag' "SYN"

pattern TCPFlag_URG :: TCPFlag
pattern $bTCPFlag_URG :: TCPFlag
$mTCPFlag_URG :: forall {r}. TCPFlag -> ((# #) -> r) -> ((# #) -> r) -> r
TCPFlag_URG = TCPFlag' "URG"

{-# COMPLETE
  TCPFlag_ACK,
  TCPFlag_CWR,
  TCPFlag_ECE,
  TCPFlag_FIN,
  TCPFlag_PSH,
  TCPFlag_RST,
  TCPFlag_SYN,
  TCPFlag_URG,
  TCPFlag'
  #-}