{-# 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.Glue.Types.CrawlerState
-- 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.Glue.Types.CrawlerState
  ( CrawlerState
      ( ..,
        CrawlerState_READY,
        CrawlerState_RUNNING,
        CrawlerState_STOPPING
      ),
  )
where

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

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

pattern CrawlerState_READY :: CrawlerState
pattern $bCrawlerState_READY :: CrawlerState
$mCrawlerState_READY :: forall {r}. CrawlerState -> ((# #) -> r) -> ((# #) -> r) -> r
CrawlerState_READY = CrawlerState' "READY"

pattern CrawlerState_RUNNING :: CrawlerState
pattern $bCrawlerState_RUNNING :: CrawlerState
$mCrawlerState_RUNNING :: forall {r}. CrawlerState -> ((# #) -> r) -> ((# #) -> r) -> r
CrawlerState_RUNNING = CrawlerState' "RUNNING"

pattern CrawlerState_STOPPING :: CrawlerState
pattern $bCrawlerState_STOPPING :: CrawlerState
$mCrawlerState_STOPPING :: forall {r}. CrawlerState -> ((# #) -> r) -> ((# #) -> r) -> r
CrawlerState_STOPPING = CrawlerState' "STOPPING"

{-# COMPLETE
  CrawlerState_READY,
  CrawlerState_RUNNING,
  CrawlerState_STOPPING,
  CrawlerState'
  #-}