{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
module Network.AWS.ELBv2.Types.Sum where
import Network.AWS.Prelude
data ActionTypeEnum =
Forward
deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic)
instance FromText ActionTypeEnum where
parser = takeLowerText >>= \case
"forward" -> pure Forward
e -> fromTextError $ "Failure parsing ActionTypeEnum from value: '" <> e
<> "'. Accepted values: forward"
instance ToText ActionTypeEnum where
toText = \case
Forward -> "forward"
instance Hashable ActionTypeEnum
instance NFData ActionTypeEnum
instance ToByteString ActionTypeEnum
instance ToQuery ActionTypeEnum
instance ToHeader ActionTypeEnum
instance FromXML ActionTypeEnum where
parseXML = parseXMLText "ActionTypeEnum"
data IPAddressType
= Dualstack
| IPV4
deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic)
instance FromText IPAddressType where
parser = takeLowerText >>= \case
"dualstack" -> pure Dualstack
"ipv4" -> pure IPV4
e -> fromTextError $ "Failure parsing IPAddressType from value: '" <> e
<> "'. Accepted values: dualstack, ipv4"
instance ToText IPAddressType where
toText = \case
Dualstack -> "dualstack"
IPV4 -> "ipv4"
instance Hashable IPAddressType
instance NFData IPAddressType
instance ToByteString IPAddressType
instance ToQuery IPAddressType
instance ToHeader IPAddressType
instance FromXML IPAddressType where
parseXML = parseXMLText "IPAddressType"
data LoadBalancerSchemeEnum
= Internal
| InternetFacing
deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic)
instance FromText LoadBalancerSchemeEnum where
parser = takeLowerText >>= \case
"internal" -> pure Internal
"internet-facing" -> pure InternetFacing
e -> fromTextError $ "Failure parsing LoadBalancerSchemeEnum from value: '" <> e
<> "'. Accepted values: internal, internet-facing"
instance ToText LoadBalancerSchemeEnum where
toText = \case
Internal -> "internal"
InternetFacing -> "internet-facing"
instance Hashable LoadBalancerSchemeEnum
instance NFData LoadBalancerSchemeEnum
instance ToByteString LoadBalancerSchemeEnum
instance ToQuery LoadBalancerSchemeEnum
instance ToHeader LoadBalancerSchemeEnum
instance FromXML LoadBalancerSchemeEnum where
parseXML = parseXMLText "LoadBalancerSchemeEnum"
data LoadBalancerStateEnum
= Active
| ActiveImpaired
| Failed
| Provisioning
deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic)
instance FromText LoadBalancerStateEnum where
parser = takeLowerText >>= \case
"active" -> pure Active
"active_impaired" -> pure ActiveImpaired
"failed" -> pure Failed
"provisioning" -> pure Provisioning
e -> fromTextError $ "Failure parsing LoadBalancerStateEnum from value: '" <> e
<> "'. Accepted values: active, active_impaired, failed, provisioning"
instance ToText LoadBalancerStateEnum where
toText = \case
Active -> "active"
ActiveImpaired -> "active_impaired"
Failed -> "failed"
Provisioning -> "provisioning"
instance Hashable LoadBalancerStateEnum
instance NFData LoadBalancerStateEnum
instance ToByteString LoadBalancerStateEnum
instance ToQuery LoadBalancerStateEnum
instance ToHeader LoadBalancerStateEnum
instance FromXML LoadBalancerStateEnum where
parseXML = parseXMLText "LoadBalancerStateEnum"
data LoadBalancerTypeEnum
= Application
| Network
deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic)
instance FromText LoadBalancerTypeEnum where
parser = takeLowerText >>= \case
"application" -> pure Application
"network" -> pure Network
e -> fromTextError $ "Failure parsing LoadBalancerTypeEnum from value: '" <> e
<> "'. Accepted values: application, network"
instance ToText LoadBalancerTypeEnum where
toText = \case
Application -> "application"
Network -> "network"
instance Hashable LoadBalancerTypeEnum
instance NFData LoadBalancerTypeEnum
instance ToByteString LoadBalancerTypeEnum
instance ToQuery LoadBalancerTypeEnum
instance ToHeader LoadBalancerTypeEnum
instance FromXML LoadBalancerTypeEnum where
parseXML = parseXMLText "LoadBalancerTypeEnum"
data ProtocolEnum
= HTTP
| HTTPS
| TCP
deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic)
instance FromText ProtocolEnum where
parser = takeLowerText >>= \case
"http" -> pure HTTP
"https" -> pure HTTPS
"tcp" -> pure TCP
e -> fromTextError $ "Failure parsing ProtocolEnum from value: '" <> e
<> "'. Accepted values: http, https, tcp"
instance ToText ProtocolEnum where
toText = \case
HTTP -> "HTTP"
HTTPS -> "HTTPS"
TCP -> "TCP"
instance Hashable ProtocolEnum
instance NFData ProtocolEnum
instance ToByteString ProtocolEnum
instance ToQuery ProtocolEnum
instance ToHeader ProtocolEnum
instance FromXML ProtocolEnum where
parseXML = parseXMLText "ProtocolEnum"
data TargetHealthReasonEnum
= Elb_InitialHealthChecking
| Elb_InternalError
| Elb_RegistrationInProgress
| Target_DeregistrationInProgress
| Target_FailedHealthChecks
| Target_IPUnusable
| Target_InvalidState
| Target_NotInUse
| Target_NotRegistered
| Target_ResponseCodeMismatch
| Target_Timeout
deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic)
instance FromText TargetHealthReasonEnum where
parser = takeLowerText >>= \case
"elb.initialhealthchecking" -> pure Elb_InitialHealthChecking
"elb.internalerror" -> pure Elb_InternalError
"elb.registrationinprogress" -> pure Elb_RegistrationInProgress
"target.deregistrationinprogress" -> pure Target_DeregistrationInProgress
"target.failedhealthchecks" -> pure Target_FailedHealthChecks
"target.ipunusable" -> pure Target_IPUnusable
"target.invalidstate" -> pure Target_InvalidState
"target.notinuse" -> pure Target_NotInUse
"target.notregistered" -> pure Target_NotRegistered
"target.responsecodemismatch" -> pure Target_ResponseCodeMismatch
"target.timeout" -> pure Target_Timeout
e -> fromTextError $ "Failure parsing TargetHealthReasonEnum from value: '" <> e
<> "'. Accepted values: elb.initialhealthchecking, elb.internalerror, elb.registrationinprogress, target.deregistrationinprogress, target.failedhealthchecks, target.ipunusable, target.invalidstate, target.notinuse, target.notregistered, target.responsecodemismatch, target.timeout"
instance ToText TargetHealthReasonEnum where
toText = \case
Elb_InitialHealthChecking -> "Elb.InitialHealthChecking"
Elb_InternalError -> "Elb.InternalError"
Elb_RegistrationInProgress -> "Elb.RegistrationInProgress"
Target_DeregistrationInProgress -> "Target.DeregistrationInProgress"
Target_FailedHealthChecks -> "Target.FailedHealthChecks"
Target_IPUnusable -> "Target.IpUnusable"
Target_InvalidState -> "Target.InvalidState"
Target_NotInUse -> "Target.NotInUse"
Target_NotRegistered -> "Target.NotRegistered"
Target_ResponseCodeMismatch -> "Target.ResponseCodeMismatch"
Target_Timeout -> "Target.Timeout"
instance Hashable TargetHealthReasonEnum
instance NFData TargetHealthReasonEnum
instance ToByteString TargetHealthReasonEnum
instance ToQuery TargetHealthReasonEnum
instance ToHeader TargetHealthReasonEnum
instance FromXML TargetHealthReasonEnum where
parseXML = parseXMLText "TargetHealthReasonEnum"
data TargetHealthStateEnum
= Draining
| Healthy
| Initial
| Unavailable
| Unhealthy
| Unused
deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic)
instance FromText TargetHealthStateEnum where
parser = takeLowerText >>= \case
"draining" -> pure Draining
"healthy" -> pure Healthy
"initial" -> pure Initial
"unavailable" -> pure Unavailable
"unhealthy" -> pure Unhealthy
"unused" -> pure Unused
e -> fromTextError $ "Failure parsing TargetHealthStateEnum from value: '" <> e
<> "'. Accepted values: draining, healthy, initial, unavailable, unhealthy, unused"
instance ToText TargetHealthStateEnum where
toText = \case
Draining -> "draining"
Healthy -> "healthy"
Initial -> "initial"
Unavailable -> "unavailable"
Unhealthy -> "unhealthy"
Unused -> "unused"
instance Hashable TargetHealthStateEnum
instance NFData TargetHealthStateEnum
instance ToByteString TargetHealthStateEnum
instance ToQuery TargetHealthStateEnum
instance ToHeader TargetHealthStateEnum
instance FromXML TargetHealthStateEnum where
parseXML = parseXMLText "TargetHealthStateEnum"
data TargetTypeEnum
= IP
| Instance
deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic)
instance FromText TargetTypeEnum where
parser = takeLowerText >>= \case
"ip" -> pure IP
"instance" -> pure Instance
e -> fromTextError $ "Failure parsing TargetTypeEnum from value: '" <> e
<> "'. Accepted values: ip, instance"
instance ToText TargetTypeEnum where
toText = \case
IP -> "ip"
Instance -> "instance"
instance Hashable TargetTypeEnum
instance NFData TargetTypeEnum
instance ToByteString TargetTypeEnum
instance ToQuery TargetTypeEnum
instance ToHeader TargetTypeEnum
instance FromXML TargetTypeEnum where
parseXML = parseXMLText "TargetTypeEnum"