{-# 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.AutoScaling.Types.LifecycleState
-- 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.AutoScaling.Types.LifecycleState
  ( LifecycleState
      ( ..,
        LifecycleState_Detached,
        LifecycleState_Detaching,
        LifecycleState_EnteringStandby,
        LifecycleState_InService,
        LifecycleState_Pending,
        LifecycleState_Pending_Proceed,
        LifecycleState_Pending_Wait,
        LifecycleState_Quarantined,
        LifecycleState_Standby,
        LifecycleState_Terminated,
        LifecycleState_Terminating,
        LifecycleState_Terminating_Proceed,
        LifecycleState_Terminating_Wait,
        LifecycleState_Warmed_Pending,
        LifecycleState_Warmed_Pending_Proceed,
        LifecycleState_Warmed_Pending_Wait,
        LifecycleState_Warmed_Running,
        LifecycleState_Warmed_Stopped,
        LifecycleState_Warmed_Terminated,
        LifecycleState_Warmed_Terminating,
        LifecycleState_Warmed_Terminating_Proceed,
        LifecycleState_Warmed_Terminating_Wait
      ),
  )
where

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

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

pattern LifecycleState_Detached :: LifecycleState
pattern $bLifecycleState_Detached :: LifecycleState
$mLifecycleState_Detached :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Detached = LifecycleState' "Detached"

pattern LifecycleState_Detaching :: LifecycleState
pattern $bLifecycleState_Detaching :: LifecycleState
$mLifecycleState_Detaching :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Detaching = LifecycleState' "Detaching"

pattern LifecycleState_EnteringStandby :: LifecycleState
pattern $bLifecycleState_EnteringStandby :: LifecycleState
$mLifecycleState_EnteringStandby :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_EnteringStandby = LifecycleState' "EnteringStandby"

pattern LifecycleState_InService :: LifecycleState
pattern $bLifecycleState_InService :: LifecycleState
$mLifecycleState_InService :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_InService = LifecycleState' "InService"

pattern LifecycleState_Pending :: LifecycleState
pattern $bLifecycleState_Pending :: LifecycleState
$mLifecycleState_Pending :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Pending = LifecycleState' "Pending"

pattern LifecycleState_Pending_Proceed :: LifecycleState
pattern $bLifecycleState_Pending_Proceed :: LifecycleState
$mLifecycleState_Pending_Proceed :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Pending_Proceed = LifecycleState' "Pending:Proceed"

pattern LifecycleState_Pending_Wait :: LifecycleState
pattern $bLifecycleState_Pending_Wait :: LifecycleState
$mLifecycleState_Pending_Wait :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Pending_Wait = LifecycleState' "Pending:Wait"

pattern LifecycleState_Quarantined :: LifecycleState
pattern $bLifecycleState_Quarantined :: LifecycleState
$mLifecycleState_Quarantined :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Quarantined = LifecycleState' "Quarantined"

pattern LifecycleState_Standby :: LifecycleState
pattern $bLifecycleState_Standby :: LifecycleState
$mLifecycleState_Standby :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Standby = LifecycleState' "Standby"

pattern LifecycleState_Terminated :: LifecycleState
pattern $bLifecycleState_Terminated :: LifecycleState
$mLifecycleState_Terminated :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Terminated = LifecycleState' "Terminated"

pattern LifecycleState_Terminating :: LifecycleState
pattern $bLifecycleState_Terminating :: LifecycleState
$mLifecycleState_Terminating :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Terminating = LifecycleState' "Terminating"

pattern LifecycleState_Terminating_Proceed :: LifecycleState
pattern $bLifecycleState_Terminating_Proceed :: LifecycleState
$mLifecycleState_Terminating_Proceed :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Terminating_Proceed = LifecycleState' "Terminating:Proceed"

pattern LifecycleState_Terminating_Wait :: LifecycleState
pattern $bLifecycleState_Terminating_Wait :: LifecycleState
$mLifecycleState_Terminating_Wait :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Terminating_Wait = LifecycleState' "Terminating:Wait"

pattern LifecycleState_Warmed_Pending :: LifecycleState
pattern $bLifecycleState_Warmed_Pending :: LifecycleState
$mLifecycleState_Warmed_Pending :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Warmed_Pending = LifecycleState' "Warmed:Pending"

pattern LifecycleState_Warmed_Pending_Proceed :: LifecycleState
pattern $bLifecycleState_Warmed_Pending_Proceed :: LifecycleState
$mLifecycleState_Warmed_Pending_Proceed :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Warmed_Pending_Proceed = LifecycleState' "Warmed:Pending:Proceed"

pattern LifecycleState_Warmed_Pending_Wait :: LifecycleState
pattern $bLifecycleState_Warmed_Pending_Wait :: LifecycleState
$mLifecycleState_Warmed_Pending_Wait :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Warmed_Pending_Wait = LifecycleState' "Warmed:Pending:Wait"

pattern LifecycleState_Warmed_Running :: LifecycleState
pattern $bLifecycleState_Warmed_Running :: LifecycleState
$mLifecycleState_Warmed_Running :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Warmed_Running = LifecycleState' "Warmed:Running"

pattern LifecycleState_Warmed_Stopped :: LifecycleState
pattern $bLifecycleState_Warmed_Stopped :: LifecycleState
$mLifecycleState_Warmed_Stopped :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Warmed_Stopped = LifecycleState' "Warmed:Stopped"

pattern LifecycleState_Warmed_Terminated :: LifecycleState
pattern $bLifecycleState_Warmed_Terminated :: LifecycleState
$mLifecycleState_Warmed_Terminated :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Warmed_Terminated = LifecycleState' "Warmed:Terminated"

pattern LifecycleState_Warmed_Terminating :: LifecycleState
pattern $bLifecycleState_Warmed_Terminating :: LifecycleState
$mLifecycleState_Warmed_Terminating :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Warmed_Terminating = LifecycleState' "Warmed:Terminating"

pattern LifecycleState_Warmed_Terminating_Proceed :: LifecycleState
pattern $bLifecycleState_Warmed_Terminating_Proceed :: LifecycleState
$mLifecycleState_Warmed_Terminating_Proceed :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Warmed_Terminating_Proceed = LifecycleState' "Warmed:Terminating:Proceed"

pattern LifecycleState_Warmed_Terminating_Wait :: LifecycleState
pattern $bLifecycleState_Warmed_Terminating_Wait :: LifecycleState
$mLifecycleState_Warmed_Terminating_Wait :: forall r. LifecycleState -> (Void# -> r) -> (Void# -> r) -> r
LifecycleState_Warmed_Terminating_Wait = LifecycleState' "Warmed:Terminating:Wait"

{-# COMPLETE
  LifecycleState_Detached,
  LifecycleState_Detaching,
  LifecycleState_EnteringStandby,
  LifecycleState_InService,
  LifecycleState_Pending,
  LifecycleState_Pending_Proceed,
  LifecycleState_Pending_Wait,
  LifecycleState_Quarantined,
  LifecycleState_Standby,
  LifecycleState_Terminated,
  LifecycleState_Terminating,
  LifecycleState_Terminating_Proceed,
  LifecycleState_Terminating_Wait,
  LifecycleState_Warmed_Pending,
  LifecycleState_Warmed_Pending_Proceed,
  LifecycleState_Warmed_Pending_Wait,
  LifecycleState_Warmed_Running,
  LifecycleState_Warmed_Stopped,
  LifecycleState_Warmed_Terminated,
  LifecycleState_Warmed_Terminating,
  LifecycleState_Warmed_Terminating_Proceed,
  LifecycleState_Warmed_Terminating_Wait,
  LifecycleState'
  #-}