{-# 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-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.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.Prelude as Prelude

newtype TCPFlag = TCPFlag' {TCPFlag -> Text
fromTCPFlag :: Core.Text}
  deriving stock
    ( Int -> TCPFlag -> ShowS
[TCPFlag] -> ShowS
TCPFlag -> String
(Int -> TCPFlag -> ShowS)
-> (TCPFlag -> String) -> ([TCPFlag] -> ShowS) -> Show TCPFlag
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]
(Int -> ReadS TCPFlag)
-> ReadS [TCPFlag]
-> ReadPrec TCPFlag
-> ReadPrec [TCPFlag]
-> Read 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
(TCPFlag -> TCPFlag -> Bool)
-> (TCPFlag -> TCPFlag -> Bool) -> Eq TCPFlag
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
Eq TCPFlag
-> (TCPFlag -> TCPFlag -> Ordering)
-> (TCPFlag -> TCPFlag -> Bool)
-> (TCPFlag -> TCPFlag -> Bool)
-> (TCPFlag -> TCPFlag -> Bool)
-> (TCPFlag -> TCPFlag -> Bool)
-> (TCPFlag -> TCPFlag -> TCPFlag)
-> (TCPFlag -> TCPFlag -> TCPFlag)
-> Ord 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
$cp1Ord :: Eq TCPFlag
Prelude.Ord,
      (forall x. TCPFlag -> Rep TCPFlag x)
-> (forall x. Rep TCPFlag x -> TCPFlag) -> Generic TCPFlag
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
    ( Int -> TCPFlag -> Int
TCPFlag -> Int
(Int -> TCPFlag -> Int) -> (TCPFlag -> Int) -> Hashable TCPFlag
forall 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 -> ()
(TCPFlag -> ()) -> NFData TCPFlag
forall a. (a -> ()) -> NFData a
rnf :: TCPFlag -> ()
$crnf :: TCPFlag -> ()
Prelude.NFData,
      Text -> Either String TCPFlag
(Text -> Either String TCPFlag) -> FromText TCPFlag
forall a. (Text -> Either String a) -> FromText a
fromText :: Text -> Either String TCPFlag
$cfromText :: Text -> Either String TCPFlag
Core.FromText,
      TCPFlag -> Text
(TCPFlag -> Text) -> ToText TCPFlag
forall a. (a -> Text) -> ToText a
toText :: TCPFlag -> Text
$ctoText :: TCPFlag -> Text
Core.ToText,
      TCPFlag -> ByteString
(TCPFlag -> ByteString) -> ToByteString TCPFlag
forall a. (a -> ByteString) -> ToByteString a
toBS :: TCPFlag -> ByteString
$ctoBS :: TCPFlag -> ByteString
Core.ToByteString,
      TCPFlag -> ByteStringBuilder
(TCPFlag -> ByteStringBuilder) -> ToLog TCPFlag
forall a. (a -> ByteStringBuilder) -> ToLog a
build :: TCPFlag -> ByteStringBuilder
$cbuild :: TCPFlag -> ByteStringBuilder
Core.ToLog,
      HeaderName -> TCPFlag -> [Header]
(HeaderName -> TCPFlag -> [Header]) -> ToHeader TCPFlag
forall a. (HeaderName -> a -> [Header]) -> ToHeader a
toHeader :: HeaderName -> TCPFlag -> [Header]
$ctoHeader :: HeaderName -> TCPFlag -> [Header]
Core.ToHeader,
      TCPFlag -> QueryString
(TCPFlag -> QueryString) -> ToQuery TCPFlag
forall a. (a -> QueryString) -> ToQuery a
toQuery :: TCPFlag -> QueryString
$ctoQuery :: TCPFlag -> QueryString
Core.ToQuery,
      Value -> Parser [TCPFlag]
Value -> Parser TCPFlag
(Value -> Parser TCPFlag)
-> (Value -> Parser [TCPFlag]) -> FromJSON 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
Core.FromJSON,
      FromJSONKeyFunction [TCPFlag]
FromJSONKeyFunction TCPFlag
FromJSONKeyFunction TCPFlag
-> FromJSONKeyFunction [TCPFlag] -> FromJSONKey TCPFlag
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [TCPFlag]
$cfromJSONKeyList :: FromJSONKeyFunction [TCPFlag]
fromJSONKey :: FromJSONKeyFunction TCPFlag
$cfromJSONKey :: FromJSONKeyFunction TCPFlag
Core.FromJSONKey,
      [TCPFlag] -> Encoding
[TCPFlag] -> Value
TCPFlag -> Encoding
TCPFlag -> Value
(TCPFlag -> Value)
-> (TCPFlag -> Encoding)
-> ([TCPFlag] -> Value)
-> ([TCPFlag] -> Encoding)
-> ToJSON TCPFlag
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
Core.ToJSON,
      ToJSONKeyFunction [TCPFlag]
ToJSONKeyFunction TCPFlag
ToJSONKeyFunction TCPFlag
-> ToJSONKeyFunction [TCPFlag] -> ToJSONKey TCPFlag
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [TCPFlag]
$ctoJSONKeyList :: ToJSONKeyFunction [TCPFlag]
toJSONKey :: ToJSONKeyFunction TCPFlag
$ctoJSONKey :: ToJSONKeyFunction TCPFlag
Core.ToJSONKey,
      [Node] -> Either String TCPFlag
([Node] -> Either String TCPFlag) -> FromXML TCPFlag
forall a. ([Node] -> Either String a) -> FromXML a
parseXML :: [Node] -> Either String TCPFlag
$cparseXML :: [Node] -> Either String TCPFlag
Core.FromXML,
      TCPFlag -> XML
(TCPFlag -> XML) -> ToXML TCPFlag
forall a. (a -> XML) -> ToXML a
toXML :: TCPFlag -> XML
$ctoXML :: TCPFlag -> XML
Core.ToXML
    )

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

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

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

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

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

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

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

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

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