[haskell-http-client] add support for enums (#6803)

* support enums for models and operation parameters

* add generateEnums cli option (default: true)

* bump stack resolver: lts-9.10

samples/client/petstore/haskell-http-client/lib/SwaggerPetstore/API.hs

@@ -359,6 +359,32 @@ instance Consumes TestEnumParameters MimeAny
 instance Produces TestEnumParameters MimeAny
 
 
+-- *** testInlineAdditionalProperties
+
+-- | @POST \/fake\/inline-additionalProperties@
+-- 
+-- test inline additionalProperties
+-- 
+-- 
+-- 
+testInlineAdditionalProperties 
+  :: (Consumes TestInlineAdditionalProperties contentType, MimeRender contentType A.Value)
+  => contentType -- ^ request content-type ('MimeType')
+  -> A.Value -- ^ "param" -  request body
+  -> SwaggerPetstoreRequest TestInlineAdditionalProperties contentType NoContent
+testInlineAdditionalProperties _ param =
+  _mkRequest "POST" ["/fake/inline-additionalProperties"]
+    `setBodyParam` param
+
+data TestInlineAdditionalProperties 
+
+-- | /Body Param/ "param" - request body
+instance HasBodyParam TestInlineAdditionalProperties A.Value 
+
+-- | @application/json@
+instance Consumes TestInlineAdditionalProperties MimeJSON
+
+
 -- *** testJsonFormData
 
 -- | @GET \/fake\/jsonFormData@
@@ -990,14 +1016,14 @@ newtype ApiKey = ApiKey { unApiKey :: Text } deriving (P.Eq, P.Show)
 newtype Body = Body { unBody :: [User] } deriving (P.Eq, P.Show, A.ToJSON)
 newtype Byte = Byte { unByte :: ByteArray } deriving (P.Eq, P.Show)
 newtype Callback = Callback { unCallback :: Text } deriving (P.Eq, P.Show)
-newtype EnumFormString = EnumFormString { unEnumFormString :: Text } deriving (P.Eq, P.Show)
-newtype EnumFormStringArray = EnumFormStringArray { unEnumFormStringArray :: [Text] } deriving (P.Eq, P.Show)
-newtype EnumHeaderString = EnumHeaderString { unEnumHeaderString :: Text } deriving (P.Eq, P.Show)
-newtype EnumHeaderStringArray = EnumHeaderStringArray { unEnumHeaderStringArray :: [Text] } deriving (P.Eq, P.Show)
-newtype EnumQueryDouble = EnumQueryDouble { unEnumQueryDouble :: Double } deriving (P.Eq, P.Show)
-newtype EnumQueryInteger = EnumQueryInteger { unEnumQueryInteger :: Int } deriving (P.Eq, P.Show)
-newtype EnumQueryString = EnumQueryString { unEnumQueryString :: Text } deriving (P.Eq, P.Show)
-newtype EnumQueryStringArray = EnumQueryStringArray { unEnumQueryStringArray :: [Text] } deriving (P.Eq, P.Show)
+newtype EnumFormString = EnumFormString { unEnumFormString :: E'EnumFormString } deriving (P.Eq, P.Show)
+newtype EnumFormStringArray = EnumFormStringArray { unEnumFormStringArray :: [E'Inner2] } deriving (P.Eq, P.Show)
+newtype EnumHeaderString = EnumHeaderString { unEnumHeaderString :: E'EnumFormString } deriving (P.Eq, P.Show)
+newtype EnumHeaderStringArray = EnumHeaderStringArray { unEnumHeaderStringArray :: [E'Inner2] } deriving (P.Eq, P.Show)
+newtype EnumQueryDouble = EnumQueryDouble { unEnumQueryDouble :: E'EnumNumber } deriving (P.Eq, P.Show)
+newtype EnumQueryInteger = EnumQueryInteger { unEnumQueryInteger :: E'EnumQueryInteger } deriving (P.Eq, P.Show)
+newtype EnumQueryString = EnumQueryString { unEnumQueryString :: E'EnumFormString } deriving (P.Eq, P.Show)
+newtype EnumQueryStringArray = EnumQueryStringArray { unEnumQueryStringArray :: [E'Inner2] } deriving (P.Eq, P.Show)
 newtype File = File { unFile :: FilePath } deriving (P.Eq, P.Show)
 newtype Int32 = Int32 { unInt32 :: Int } deriving (P.Eq, P.Show)
 newtype Int64 = Int64 { unInt64 :: Integer } deriving (P.Eq, P.Show)
@@ -1017,7 +1043,7 @@ newtype ParamString = ParamString { unParamString :: Text } deriving (P.Eq, P.Sh
 newtype Password = Password { unPassword :: Text } deriving (P.Eq, P.Show)
 newtype PatternWithoutDelimiter = PatternWithoutDelimiter { unPatternWithoutDelimiter :: Text } deriving (P.Eq, P.Show)
 newtype PetId = PetId { unPetId :: Integer } deriving (P.Eq, P.Show)
-newtype Status = Status { unStatus :: [Text] } deriving (P.Eq, P.Show)
+newtype Status = Status { unStatus :: [E'Status2] } deriving (P.Eq, P.Show)
 newtype StatusText = StatusText { unStatusText :: Text } deriving (P.Eq, P.Show)
 newtype Tags = Tags { unTags :: [Text] } deriving (P.Eq, P.Show)
 newtype Username = Username { unUsername :: Text } deriving (P.Eq, P.Show)

samples/client/petstore/haskell-http-client/lib/SwaggerPetstore/Model.hs

@@ -18,6 +18,8 @@ Module : SwaggerPetstore.Model
 {-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE DeriveTraversable #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
@@ -28,9 +30,11 @@ Module : SwaggerPetstore.Model
 module SwaggerPetstore.Model where
 
 import SwaggerPetstore.Core
+import SwaggerPetstore.MimeTypes
 
 import Data.Aeson ((.:),(.:!),(.:?),(.=))
 
+import qualified Control.Arrow as P (left)
 import qualified Data.Aeson as A
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Lazy as BL
@@ -49,7 +53,7 @@ import qualified Web.HttpApiData as WH
 import Control.Applicative ((<|>))
 import Control.Applicative (Alternative)
 import Data.Text (Text)
-import Prelude (($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)
+import Prelude (($), (.),(<$>),(<*>),(>>=),(=<<),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)
 
 import qualified Prelude as P
 
@@ -90,7 +94,6 @@ mkAdditionalPropertiesClass =
   , additionalPropertiesClassMapOfMapProperty = Nothing
   }
 
-
 -- ** Animal
 -- | Animal
 data Animal = Animal
@@ -124,7 +127,6 @@ mkAnimal animalClassName =
   , animalColor = Nothing
   }
 
-
 -- ** AnimalFarm
 -- | AnimalFarm
 data AnimalFarm = AnimalFarm
@@ -153,7 +155,6 @@ mkAnimalFarm =
   { 
   }
 
-
 -- ** ApiResponse
 -- | ApiResponse
 data ApiResponse = ApiResponse
@@ -190,7 +191,6 @@ mkApiResponse =
   , apiResponseMessage = Nothing
   }
 
-
 -- ** ArrayOfArrayOfNumberOnly
 -- | ArrayOfArrayOfNumberOnly
 data ArrayOfArrayOfNumberOnly = ArrayOfArrayOfNumberOnly
@@ -219,7 +219,6 @@ mkArrayOfArrayOfNumberOnly =
   { arrayOfArrayOfNumberOnlyArrayArrayNumber = Nothing
   }
 
-
 -- ** ArrayOfNumberOnly
 -- | ArrayOfNumberOnly
 data ArrayOfNumberOnly = ArrayOfNumberOnly
@@ -248,7 +247,6 @@ mkArrayOfNumberOnly =
   { arrayOfNumberOnlyArrayNumber = Nothing
   }
 
-
 -- ** ArrayTest
 -- | ArrayTest
 data ArrayTest = ArrayTest
@@ -285,7 +283,6 @@ mkArrayTest =
   , arrayTestArrayArrayOfModel = Nothing
   }
 
-
 -- ** Capitalization
 -- | Capitalization
 data Capitalization = Capitalization
@@ -334,7 +331,6 @@ mkCapitalization =
   , capitalizationAttName = Nothing
   }
 
-
 -- ** Category
 -- | Category
 data Category = Category
@@ -367,7 +363,6 @@ mkCategory =
   , categoryName = Nothing
   }
 
-
 -- ** ClassModel
 -- | ClassModel
 -- Model for testing model with \"_class\" property
@@ -397,7 +392,6 @@ mkClassModel =
   { classModelClass = Nothing
   }
 
-
 -- ** Client
 -- | Client
 data Client = Client
@@ -426,12 +420,11 @@ mkClient =
   { clientClient = Nothing
   }
 
-
 -- ** EnumArrays
 -- | EnumArrays
 data EnumArrays = EnumArrays
-  { enumArraysJustSymbol :: !(Maybe Text) -- ^ "just_symbol"
-  , enumArraysArrayEnum :: !(Maybe [Text]) -- ^ "array_enum"
+  { enumArraysJustSymbol :: !(Maybe E'JustSymbol) -- ^ "just_symbol"
+  , enumArraysArrayEnum :: !(Maybe [E'ArrayEnum]) -- ^ "array_enum"
   } deriving (P.Show, P.Eq, P.Typeable)
 
 -- | FromJSON EnumArrays
@@ -459,42 +452,12 @@ mkEnumArrays =
   , enumArraysArrayEnum = Nothing
   }
 
-
--- ** EnumClass
--- | EnumClass
-data EnumClass = EnumClass
-  { 
-  } deriving (P.Show, P.Eq, P.Typeable)
-
--- | FromJSON EnumClass
-instance A.FromJSON EnumClass where
-  parseJSON = A.withObject "EnumClass" $ \o ->
-    pure EnumClass
-      
-
--- | ToJSON EnumClass
-instance A.ToJSON EnumClass where
-  toJSON EnumClass  =
-   _omitNulls
-      [ 
-      ]
-
-
--- | Construct a value of type 'EnumClass' (by applying it's required fields, if any)
-mkEnumClass
-  :: EnumClass
-mkEnumClass =
-  EnumClass
-  { 
-  }
-
-
 -- ** EnumTest
 -- | EnumTest
 data EnumTest = EnumTest
-  { enumTestEnumString :: !(Maybe Text) -- ^ "enum_string"
-  , enumTestEnumInteger :: !(Maybe Int) -- ^ "enum_integer"
-  , enumTestEnumNumber :: !(Maybe Double) -- ^ "enum_number"
+  { enumTestEnumString :: !(Maybe E'EnumString) -- ^ "enum_string"
+  , enumTestEnumInteger :: !(Maybe E'EnumInteger) -- ^ "enum_integer"
+  , enumTestEnumNumber :: !(Maybe E'EnumNumber) -- ^ "enum_number"
   , enumTestOuterEnum :: !(Maybe OuterEnum) -- ^ "outerEnum"
   } deriving (P.Show, P.Eq, P.Typeable)
 
@@ -529,7 +492,6 @@ mkEnumTest =
   , enumTestOuterEnum = Nothing
   }
 
-
 -- ** FormatTest
 -- | FormatTest
 data FormatTest = FormatTest
@@ -610,7 +572,6 @@ mkFormatTest formatTestNumber formatTestByte formatTestDate formatTestPassword =
   , formatTestPassword
   }
 
-
 -- ** HasOnlyReadOnly
 -- | HasOnlyReadOnly
 data HasOnlyReadOnly = HasOnlyReadOnly
@@ -643,12 +604,11 @@ mkHasOnlyReadOnly =
   , hasOnlyReadOnlyFoo = Nothing
   }
 
-
 -- ** MapTest
 -- | MapTest
 data MapTest = MapTest
   { mapTestMapMapOfString :: !(Maybe (Map.Map String (Map.Map String Text))) -- ^ "map_map_of_string"
-  , mapTestMapOfEnumString :: !(Maybe (Map.Map String Text)) -- ^ "map_of_enum_string"
+  , mapTestMapOfEnumString :: !(Maybe (Map.Map String E'Inner)) -- ^ "map_of_enum_string"
   } deriving (P.Show, P.Eq, P.Typeable)
 
 -- | FromJSON MapTest
@@ -676,7 +636,6 @@ mkMapTest =
   , mapTestMapOfEnumString = Nothing
   }
 
-
 -- ** MixedPropertiesAndAdditionalPropertiesClass
 -- | MixedPropertiesAndAdditionalPropertiesClass
 data MixedPropertiesAndAdditionalPropertiesClass = MixedPropertiesAndAdditionalPropertiesClass
@@ -713,7 +672,6 @@ mkMixedPropertiesAndAdditionalPropertiesClass =
   , mixedPropertiesAndAdditionalPropertiesClassMap = Nothing
   }
 
-
 -- ** Model200Response
 -- | Model200Response
 -- Model for testing model name starting with number
@@ -747,7 +705,6 @@ mkModel200Response =
   , model200ResponseClass = Nothing
   }
 
-
 -- ** ModelList
 -- | ModelList
 data ModelList = ModelList
@@ -776,7 +733,6 @@ mkModelList =
   { modelList123List = Nothing
   }
 
-
 -- ** ModelReturn
 -- | ModelReturn
 -- Model for testing reserved words
@@ -806,7 +762,6 @@ mkModelReturn =
   { modelReturnReturn = Nothing
   }
 
-
 -- ** Name
 -- | Name
 -- Model for testing model name same as property name
@@ -849,7 +804,6 @@ mkName nameName =
   , name123Number = Nothing
   }
 
-
 -- ** NumberOnly
 -- | NumberOnly
 data NumberOnly = NumberOnly
@@ -878,7 +832,6 @@ mkNumberOnly =
   { numberOnlyJustNumber = Nothing
   }
 
-
 -- ** Order
 -- | Order
 data Order = Order
@@ -886,7 +839,7 @@ data Order = Order
   , orderPetId :: !(Maybe Integer) -- ^ "petId"
   , orderQuantity :: !(Maybe Int) -- ^ "quantity"
   , orderShipDate :: !(Maybe DateTime) -- ^ "shipDate"
-  , orderStatus :: !(Maybe Text) -- ^ "status" - Order Status
+  , orderStatus :: !(Maybe E'Status) -- ^ "status" - Order Status
   , orderComplete :: !(Maybe Bool) -- ^ "complete"
   } deriving (P.Show, P.Eq, P.Typeable)
 
@@ -927,7 +880,6 @@ mkOrder =
   , orderComplete = Nothing
   }
 
-
 -- ** OuterBoolean
 -- | OuterBoolean
 newtype OuterBoolean = OuterBoolean
@@ -935,7 +887,6 @@ newtype OuterBoolean = OuterBoolean
   } deriving (P.Eq, P.Show, P.Typeable, A.ToJSON, A.FromJSON, WH.ToHttpApiData, WH.FromHttpApiData)
 
 
-
 -- ** OuterComposite
 -- | OuterComposite
 data OuterComposite = OuterComposite
@@ -972,36 +923,6 @@ mkOuterComposite =
   , outerCompositeMyBoolean = Nothing
   }
 
-
--- ** OuterEnum
--- | OuterEnum
-data OuterEnum = OuterEnum
-  { 
-  } deriving (P.Show, P.Eq, P.Typeable)
-
--- | FromJSON OuterEnum
-instance A.FromJSON OuterEnum where
-  parseJSON = A.withObject "OuterEnum" $ \o ->
-    pure OuterEnum
-      
-
--- | ToJSON OuterEnum
-instance A.ToJSON OuterEnum where
-  toJSON OuterEnum  =
-   _omitNulls
-      [ 
-      ]
-
-
--- | Construct a value of type 'OuterEnum' (by applying it's required fields, if any)
-mkOuterEnum
-  :: OuterEnum
-mkOuterEnum =
-  OuterEnum
-  { 
-  }
-
-
 -- ** OuterNumber
 -- | OuterNumber
 newtype OuterNumber = OuterNumber
@@ -1009,7 +930,6 @@ newtype OuterNumber = OuterNumber
   } deriving (P.Eq, P.Show, P.Typeable, A.ToJSON, A.FromJSON, WH.ToHttpApiData, WH.FromHttpApiData)
 
 
-
 -- ** OuterString
 -- | OuterString
 newtype OuterString = OuterString
@@ -1017,7 +937,6 @@ newtype OuterString = OuterString
   } deriving (P.Eq, P.Show, P.Typeable, A.ToJSON, A.FromJSON, WH.ToHttpApiData, WH.FromHttpApiData)
 
 
-
 -- ** Pet
 -- | Pet
 data Pet = Pet
@@ -1026,7 +945,7 @@ data Pet = Pet
   , petName :: !(Text) -- ^ /Required/ "name"
   , petPhotoUrls :: !([Text]) -- ^ /Required/ "photoUrls"
   , petTags :: !(Maybe [Tag]) -- ^ "tags"
-  , petStatus :: !(Maybe Text) -- ^ "status" - pet status in the store
+  , petStatus :: !(Maybe E'Status2) -- ^ "status" - pet status in the store
   } deriving (P.Show, P.Eq, P.Typeable)
 
 -- | FromJSON Pet
@@ -1068,7 +987,6 @@ mkPet petName petPhotoUrls =
   , petStatus = Nothing
   }
 
-
 -- ** ReadOnlyFirst
 -- | ReadOnlyFirst
 data ReadOnlyFirst = ReadOnlyFirst
@@ -1101,7 +1019,6 @@ mkReadOnlyFirst =
   , readOnlyFirstBaz = Nothing
   }
 
-
 -- ** SpecialModelName
 -- | SpecialModelName
 data SpecialModelName = SpecialModelName
@@ -1130,7 +1047,6 @@ mkSpecialModelName =
   { specialModelNameSpecialPropertyName = Nothing
   }
 
-
 -- ** Tag
 -- | Tag
 data Tag = Tag
@@ -1163,7 +1079,6 @@ mkTag =
   , tagName = Nothing
   }
 
-
 -- ** User
 -- | User
 data User = User
@@ -1220,7 +1135,6 @@ mkUser =
   , userUserStatus = Nothing
   }
 
-
 -- ** Cat
 -- | Cat
 data Cat = Cat
@@ -1258,7 +1172,6 @@ mkCat catClassName =
   , catDeclawed = Nothing
   }
 
-
 -- ** Dog
 -- | Dog
 data Dog = Dog
@@ -1297,4 +1210,388 @@ mkDog dogClassName =
   }
 
 
+-- * Enums
 
+
+-- ** E'ArrayEnum
+
+-- | Enum of 'Text'
+data E'ArrayEnum
+  = E'ArrayEnum'Fish -- ^ @"fish"@
+  | E'ArrayEnum'Crab -- ^ @"crab"@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'ArrayEnum where toJSON = A.toJSON . fromE'ArrayEnum
+instance A.FromJSON E'ArrayEnum where parseJSON o = P.either P.fail (pure . P.id) . toE'ArrayEnum =<< A.parseJSON o
+instance WH.ToHttpApiData E'ArrayEnum where toQueryParam = WH.toQueryParam . fromE'ArrayEnum
+instance WH.FromHttpApiData E'ArrayEnum where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'ArrayEnum
+instance MimeRender MimeMultipartFormData E'ArrayEnum where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'ArrayEnum' enum
+fromE'ArrayEnum :: E'ArrayEnum -> Text
+fromE'ArrayEnum = \case
+  E'ArrayEnum'Fish -> "fish"
+  E'ArrayEnum'Crab -> "crab"
+
+-- | parse 'E'ArrayEnum' enum
+toE'ArrayEnum :: Text -> P.Either String E'ArrayEnum
+toE'ArrayEnum = \case
+  "fish" -> P.Right E'ArrayEnum'Fish
+  "crab" -> P.Right E'ArrayEnum'Crab
+  s -> P.Left $ "toE'ArrayEnum: enum parse failure: " P.++ P.show s
+
+
+-- ** E'EnumFormString
+
+-- | Enum of 'Text'
+data E'EnumFormString
+  = E'EnumFormString'_abc -- ^ @"_abc"@
+  | E'EnumFormString'_efg -- ^ @"-efg"@
+  | E'EnumFormString'_xyz -- ^ @"(xyz)"@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'EnumFormString where toJSON = A.toJSON . fromE'EnumFormString
+instance A.FromJSON E'EnumFormString where parseJSON o = P.either P.fail (pure . P.id) . toE'EnumFormString =<< A.parseJSON o
+instance WH.ToHttpApiData E'EnumFormString where toQueryParam = WH.toQueryParam . fromE'EnumFormString
+instance WH.FromHttpApiData E'EnumFormString where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'EnumFormString
+instance MimeRender MimeMultipartFormData E'EnumFormString where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'EnumFormString' enum
+fromE'EnumFormString :: E'EnumFormString -> Text
+fromE'EnumFormString = \case
+  E'EnumFormString'_abc -> "_abc"
+  E'EnumFormString'_efg -> "-efg"
+  E'EnumFormString'_xyz -> "(xyz)"
+
+-- | parse 'E'EnumFormString' enum
+toE'EnumFormString :: Text -> P.Either String E'EnumFormString
+toE'EnumFormString = \case
+  "_abc" -> P.Right E'EnumFormString'_abc
+  "-efg" -> P.Right E'EnumFormString'_efg
+  "(xyz)" -> P.Right E'EnumFormString'_xyz
+  s -> P.Left $ "toE'EnumFormString: enum parse failure: " P.++ P.show s
+
+
+-- ** E'EnumInteger
+
+-- | Enum of 'Int'
+data E'EnumInteger
+  = E'EnumInteger'Num1 -- ^ @1@
+  | E'EnumInteger'NumMinus_1 -- ^ @-1@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'EnumInteger where toJSON = A.toJSON . fromE'EnumInteger
+instance A.FromJSON E'EnumInteger where parseJSON o = P.either P.fail (pure . P.id) . toE'EnumInteger =<< A.parseJSON o
+instance WH.ToHttpApiData E'EnumInteger where toQueryParam = WH.toQueryParam . fromE'EnumInteger
+instance WH.FromHttpApiData E'EnumInteger where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'EnumInteger
+instance MimeRender MimeMultipartFormData E'EnumInteger where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'EnumInteger' enum
+fromE'EnumInteger :: E'EnumInteger -> Int
+fromE'EnumInteger = \case
+  E'EnumInteger'Num1 -> 1
+  E'EnumInteger'NumMinus_1 -> -1
+
+-- | parse 'E'EnumInteger' enum
+toE'EnumInteger :: Int -> P.Either String E'EnumInteger
+toE'EnumInteger = \case
+  1 -> P.Right E'EnumInteger'Num1
+  -1 -> P.Right E'EnumInteger'NumMinus_1
+  s -> P.Left $ "toE'EnumInteger: enum parse failure: " P.++ P.show s
+
+
+-- ** E'EnumNumber
+
+-- | Enum of 'Double'
+data E'EnumNumber
+  = E'EnumNumber'Num1_Dot_1 -- ^ @1.1@
+  | E'EnumNumber'NumMinus_1_Dot_2 -- ^ @-1.2@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'EnumNumber where toJSON = A.toJSON . fromE'EnumNumber
+instance A.FromJSON E'EnumNumber where parseJSON o = P.either P.fail (pure . P.id) . toE'EnumNumber =<< A.parseJSON o
+instance WH.ToHttpApiData E'EnumNumber where toQueryParam = WH.toQueryParam . fromE'EnumNumber
+instance WH.FromHttpApiData E'EnumNumber where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'EnumNumber
+instance MimeRender MimeMultipartFormData E'EnumNumber where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'EnumNumber' enum
+fromE'EnumNumber :: E'EnumNumber -> Double
+fromE'EnumNumber = \case
+  E'EnumNumber'Num1_Dot_1 -> 1.1
+  E'EnumNumber'NumMinus_1_Dot_2 -> -1.2
+
+-- | parse 'E'EnumNumber' enum
+toE'EnumNumber :: Double -> P.Either String E'EnumNumber
+toE'EnumNumber = \case
+  1.1 -> P.Right E'EnumNumber'Num1_Dot_1
+  -1.2 -> P.Right E'EnumNumber'NumMinus_1_Dot_2
+  s -> P.Left $ "toE'EnumNumber: enum parse failure: " P.++ P.show s
+
+
+-- ** E'EnumQueryInteger
+
+-- | Enum of 'Int'
+data E'EnumQueryInteger
+  = E'EnumQueryInteger'Num1 -- ^ @1@
+  | E'EnumQueryInteger'NumMinus_2 -- ^ @-2@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'EnumQueryInteger where toJSON = A.toJSON . fromE'EnumQueryInteger
+instance A.FromJSON E'EnumQueryInteger where parseJSON o = P.either P.fail (pure . P.id) . toE'EnumQueryInteger =<< A.parseJSON o
+instance WH.ToHttpApiData E'EnumQueryInteger where toQueryParam = WH.toQueryParam . fromE'EnumQueryInteger
+instance WH.FromHttpApiData E'EnumQueryInteger where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'EnumQueryInteger
+instance MimeRender MimeMultipartFormData E'EnumQueryInteger where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'EnumQueryInteger' enum
+fromE'EnumQueryInteger :: E'EnumQueryInteger -> Int
+fromE'EnumQueryInteger = \case
+  E'EnumQueryInteger'Num1 -> 1
+  E'EnumQueryInteger'NumMinus_2 -> -2
+
+-- | parse 'E'EnumQueryInteger' enum
+toE'EnumQueryInteger :: Int -> P.Either String E'EnumQueryInteger
+toE'EnumQueryInteger = \case
+  1 -> P.Right E'EnumQueryInteger'Num1
+  -2 -> P.Right E'EnumQueryInteger'NumMinus_2
+  s -> P.Left $ "toE'EnumQueryInteger: enum parse failure: " P.++ P.show s
+
+
+-- ** E'EnumString
+
+-- | Enum of 'Text'
+data E'EnumString
+  = E'EnumString'UPPER -- ^ @"UPPER"@
+  | E'EnumString'Lower -- ^ @"lower"@
+  | E'EnumString'Empty -- ^ @""@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'EnumString where toJSON = A.toJSON . fromE'EnumString
+instance A.FromJSON E'EnumString where parseJSON o = P.either P.fail (pure . P.id) . toE'EnumString =<< A.parseJSON o
+instance WH.ToHttpApiData E'EnumString where toQueryParam = WH.toQueryParam . fromE'EnumString
+instance WH.FromHttpApiData E'EnumString where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'EnumString
+instance MimeRender MimeMultipartFormData E'EnumString where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'EnumString' enum
+fromE'EnumString :: E'EnumString -> Text
+fromE'EnumString = \case
+  E'EnumString'UPPER -> "UPPER"
+  E'EnumString'Lower -> "lower"
+  E'EnumString'Empty -> ""
+
+-- | parse 'E'EnumString' enum
+toE'EnumString :: Text -> P.Either String E'EnumString
+toE'EnumString = \case
+  "UPPER" -> P.Right E'EnumString'UPPER
+  "lower" -> P.Right E'EnumString'Lower
+  "" -> P.Right E'EnumString'Empty
+  s -> P.Left $ "toE'EnumString: enum parse failure: " P.++ P.show s
+
+
+-- ** E'Inner
+
+-- | Enum of 'Text'
+data E'Inner
+  = E'Inner'UPPER -- ^ @"UPPER"@
+  | E'Inner'Lower -- ^ @"lower"@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'Inner where toJSON = A.toJSON . fromE'Inner
+instance A.FromJSON E'Inner where parseJSON o = P.either P.fail (pure . P.id) . toE'Inner =<< A.parseJSON o
+instance WH.ToHttpApiData E'Inner where toQueryParam = WH.toQueryParam . fromE'Inner
+instance WH.FromHttpApiData E'Inner where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Inner
+instance MimeRender MimeMultipartFormData E'Inner where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'Inner' enum
+fromE'Inner :: E'Inner -> Text
+fromE'Inner = \case
+  E'Inner'UPPER -> "UPPER"
+  E'Inner'Lower -> "lower"
+
+-- | parse 'E'Inner' enum
+toE'Inner :: Text -> P.Either String E'Inner
+toE'Inner = \case
+  "UPPER" -> P.Right E'Inner'UPPER
+  "lower" -> P.Right E'Inner'Lower
+  s -> P.Left $ "toE'Inner: enum parse failure: " P.++ P.show s
+
+
+-- ** E'Inner2
+
+-- | Enum of 'Text'
+data E'Inner2
+  = E'Inner2'GreaterThan -- ^ @">"@
+  | E'Inner2'Dollar -- ^ @"$"@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'Inner2 where toJSON = A.toJSON . fromE'Inner2
+instance A.FromJSON E'Inner2 where parseJSON o = P.either P.fail (pure . P.id) . toE'Inner2 =<< A.parseJSON o
+instance WH.ToHttpApiData E'Inner2 where toQueryParam = WH.toQueryParam . fromE'Inner2
+instance WH.FromHttpApiData E'Inner2 where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Inner2
+instance MimeRender MimeMultipartFormData E'Inner2 where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'Inner2' enum
+fromE'Inner2 :: E'Inner2 -> Text
+fromE'Inner2 = \case
+  E'Inner2'GreaterThan -> ">"
+  E'Inner2'Dollar -> "$"
+
+-- | parse 'E'Inner2' enum
+toE'Inner2 :: Text -> P.Either String E'Inner2
+toE'Inner2 = \case
+  ">" -> P.Right E'Inner2'GreaterThan
+  "$" -> P.Right E'Inner2'Dollar
+  s -> P.Left $ "toE'Inner2: enum parse failure: " P.++ P.show s
+
+
+-- ** E'JustSymbol
+
+-- | Enum of 'Text'
+data E'JustSymbol
+  = E'JustSymbol'Greater_Than_Or_Equal_To -- ^ @">="@
+  | E'JustSymbol'Dollar -- ^ @"$"@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'JustSymbol where toJSON = A.toJSON . fromE'JustSymbol
+instance A.FromJSON E'JustSymbol where parseJSON o = P.either P.fail (pure . P.id) . toE'JustSymbol =<< A.parseJSON o
+instance WH.ToHttpApiData E'JustSymbol where toQueryParam = WH.toQueryParam . fromE'JustSymbol
+instance WH.FromHttpApiData E'JustSymbol where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'JustSymbol
+instance MimeRender MimeMultipartFormData E'JustSymbol where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'JustSymbol' enum
+fromE'JustSymbol :: E'JustSymbol -> Text
+fromE'JustSymbol = \case
+  E'JustSymbol'Greater_Than_Or_Equal_To -> ">="
+  E'JustSymbol'Dollar -> "$"
+
+-- | parse 'E'JustSymbol' enum
+toE'JustSymbol :: Text -> P.Either String E'JustSymbol
+toE'JustSymbol = \case
+  ">=" -> P.Right E'JustSymbol'Greater_Than_Or_Equal_To
+  "$" -> P.Right E'JustSymbol'Dollar
+  s -> P.Left $ "toE'JustSymbol: enum parse failure: " P.++ P.show s
+
+
+-- ** E'Status
+
+-- | Enum of 'Text' . 
+-- Order Status
+data E'Status
+  = E'Status'Placed -- ^ @"placed"@
+  | E'Status'Approved -- ^ @"approved"@
+  | E'Status'Delivered -- ^ @"delivered"@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'Status where toJSON = A.toJSON . fromE'Status
+instance A.FromJSON E'Status where parseJSON o = P.either P.fail (pure . P.id) . toE'Status =<< A.parseJSON o
+instance WH.ToHttpApiData E'Status where toQueryParam = WH.toQueryParam . fromE'Status
+instance WH.FromHttpApiData E'Status where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Status
+instance MimeRender MimeMultipartFormData E'Status where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'Status' enum
+fromE'Status :: E'Status -> Text
+fromE'Status = \case
+  E'Status'Placed -> "placed"
+  E'Status'Approved -> "approved"
+  E'Status'Delivered -> "delivered"
+
+-- | parse 'E'Status' enum
+toE'Status :: Text -> P.Either String E'Status
+toE'Status = \case
+  "placed" -> P.Right E'Status'Placed
+  "approved" -> P.Right E'Status'Approved
+  "delivered" -> P.Right E'Status'Delivered
+  s -> P.Left $ "toE'Status: enum parse failure: " P.++ P.show s
+
+
+-- ** E'Status2
+
+-- | Enum of 'Text' . 
+-- pet status in the store
+data E'Status2
+  = E'Status2'Available -- ^ @"available"@
+  | E'Status2'Pending -- ^ @"pending"@
+  | E'Status2'Sold -- ^ @"sold"@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON E'Status2 where toJSON = A.toJSON . fromE'Status2
+instance A.FromJSON E'Status2 where parseJSON o = P.either P.fail (pure . P.id) . toE'Status2 =<< A.parseJSON o
+instance WH.ToHttpApiData E'Status2 where toQueryParam = WH.toQueryParam . fromE'Status2
+instance WH.FromHttpApiData E'Status2 where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Status2
+instance MimeRender MimeMultipartFormData E'Status2 where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'E'Status2' enum
+fromE'Status2 :: E'Status2 -> Text
+fromE'Status2 = \case
+  E'Status2'Available -> "available"
+  E'Status2'Pending -> "pending"
+  E'Status2'Sold -> "sold"
+
+-- | parse 'E'Status2' enum
+toE'Status2 :: Text -> P.Either String E'Status2
+toE'Status2 = \case
+  "available" -> P.Right E'Status2'Available
+  "pending" -> P.Right E'Status2'Pending
+  "sold" -> P.Right E'Status2'Sold
+  s -> P.Left $ "toE'Status2: enum parse failure: " P.++ P.show s
+
+
+-- ** EnumClass
+
+-- | Enum of 'Text'
+data EnumClass
+  = EnumClass'_abc -- ^ @"_abc"@
+  | EnumClass'_efg -- ^ @"-efg"@
+  | EnumClass'_xyz -- ^ @"(xyz)"@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON EnumClass where toJSON = A.toJSON . fromEnumClass
+instance A.FromJSON EnumClass where parseJSON o = P.either P.fail (pure . P.id) . toEnumClass =<< A.parseJSON o
+instance WH.ToHttpApiData EnumClass where toQueryParam = WH.toQueryParam . fromEnumClass
+instance WH.FromHttpApiData EnumClass where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toEnumClass
+instance MimeRender MimeMultipartFormData EnumClass where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'EnumClass' enum
+fromEnumClass :: EnumClass -> Text
+fromEnumClass = \case
+  EnumClass'_abc -> "_abc"
+  EnumClass'_efg -> "-efg"
+  EnumClass'_xyz -> "(xyz)"
+
+-- | parse 'EnumClass' enum
+toEnumClass :: Text -> P.Either String EnumClass
+toEnumClass = \case
+  "_abc" -> P.Right EnumClass'_abc
+  "-efg" -> P.Right EnumClass'_efg
+  "(xyz)" -> P.Right EnumClass'_xyz
+  s -> P.Left $ "toEnumClass: enum parse failure: " P.++ P.show s
+
+
+-- ** OuterEnum
+
+-- | Enum of 'Text'
+data OuterEnum
+  = OuterEnum'Placed -- ^ @"placed"@
+  | OuterEnum'Approved -- ^ @"approved"@
+  | OuterEnum'Delivered -- ^ @"delivered"@
+  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)
+
+instance A.ToJSON OuterEnum where toJSON = A.toJSON . fromOuterEnum
+instance A.FromJSON OuterEnum where parseJSON o = P.either P.fail (pure . P.id) . toOuterEnum =<< A.parseJSON o
+instance WH.ToHttpApiData OuterEnum where toQueryParam = WH.toQueryParam . fromOuterEnum
+instance WH.FromHttpApiData OuterEnum where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toOuterEnum
+instance MimeRender MimeMultipartFormData OuterEnum where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | unwrap 'OuterEnum' enum
+fromOuterEnum :: OuterEnum -> Text
+fromOuterEnum = \case
+  OuterEnum'Placed -> "placed"
+  OuterEnum'Approved -> "approved"
+  OuterEnum'Delivered -> "delivered"
+
+-- | parse 'OuterEnum' enum
+toOuterEnum :: Text -> P.Either String OuterEnum
+toOuterEnum = \case
+  "placed" -> P.Right OuterEnum'Placed
+  "approved" -> P.Right OuterEnum'Approved
+  "delivered" -> P.Right OuterEnum'Delivered
+  s -> P.Left $ "toOuterEnum: enum parse failure: " P.++ P.show s

samples/client/petstore/haskell-http-client/lib/SwaggerPetstore/ModelLens.hs

@@ -194,12 +194,12 @@ clientClientL f Client{..} = (\clientClient -> Client { clientClient, ..} ) <$>
 -- * EnumArrays
 
 -- | 'enumArraysJustSymbol' Lens
-enumArraysJustSymbolL :: Lens_' EnumArrays (Maybe Text)
+enumArraysJustSymbolL :: Lens_' EnumArrays (Maybe E'JustSymbol)
 enumArraysJustSymbolL f EnumArrays{..} = (\enumArraysJustSymbol -> EnumArrays { enumArraysJustSymbol, ..} ) <$> f enumArraysJustSymbol
 {-# INLINE enumArraysJustSymbolL #-}
 
 -- | 'enumArraysArrayEnum' Lens
-enumArraysArrayEnumL :: Lens_' EnumArrays (Maybe [Text])
+enumArraysArrayEnumL :: Lens_' EnumArrays (Maybe [E'ArrayEnum])
 enumArraysArrayEnumL f EnumArrays{..} = (\enumArraysArrayEnum -> EnumArrays { enumArraysArrayEnum, ..} ) <$> f enumArraysArrayEnum
 {-# INLINE enumArraysArrayEnumL #-}
 
@@ -212,17 +212,17 @@ enumArraysArrayEnumL f EnumArrays{..} = (\enumArraysArrayEnum -> EnumArrays { en
 -- * EnumTest
 
 -- | 'enumTestEnumString' Lens
-enumTestEnumStringL :: Lens_' EnumTest (Maybe Text)
+enumTestEnumStringL :: Lens_' EnumTest (Maybe E'EnumString)
 enumTestEnumStringL f EnumTest{..} = (\enumTestEnumString -> EnumTest { enumTestEnumString, ..} ) <$> f enumTestEnumString
 {-# INLINE enumTestEnumStringL #-}
 
 -- | 'enumTestEnumInteger' Lens
-enumTestEnumIntegerL :: Lens_' EnumTest (Maybe Int)
+enumTestEnumIntegerL :: Lens_' EnumTest (Maybe E'EnumInteger)
 enumTestEnumIntegerL f EnumTest{..} = (\enumTestEnumInteger -> EnumTest { enumTestEnumInteger, ..} ) <$> f enumTestEnumInteger
 {-# INLINE enumTestEnumIntegerL #-}
 
 -- | 'enumTestEnumNumber' Lens
-enumTestEnumNumberL :: Lens_' EnumTest (Maybe Double)
+enumTestEnumNumberL :: Lens_' EnumTest (Maybe E'EnumNumber)
 enumTestEnumNumberL f EnumTest{..} = (\enumTestEnumNumber -> EnumTest { enumTestEnumNumber, ..} ) <$> f enumTestEnumNumber
 {-# INLINE enumTestEnumNumberL #-}
 
@@ -324,7 +324,7 @@ mapTestMapMapOfStringL f MapTest{..} = (\mapTestMapMapOfString -> MapTest { mapT
 {-# INLINE mapTestMapMapOfStringL #-}
 
 -- | 'mapTestMapOfEnumString' Lens
-mapTestMapOfEnumStringL :: Lens_' MapTest (Maybe (Map.Map String Text))
+mapTestMapOfEnumStringL :: Lens_' MapTest (Maybe (Map.Map String E'Inner))
 mapTestMapOfEnumStringL f MapTest{..} = (\mapTestMapOfEnumString -> MapTest { mapTestMapOfEnumString, ..} ) <$> f mapTestMapOfEnumString
 {-# INLINE mapTestMapOfEnumStringL #-}
 
@@ -437,7 +437,7 @@ orderShipDateL f Order{..} = (\orderShipDate -> Order { orderShipDate, ..} ) <$>
 {-# INLINE orderShipDateL #-}
 
 -- | 'orderStatus' Lens
-orderStatusL :: Lens_' Order (Maybe Text)
+orderStatusL :: Lens_' Order (Maybe E'Status)
 orderStatusL f Order{..} = (\orderStatus -> Order { orderStatus, ..} ) <$> f orderStatus
 {-# INLINE orderStatusL #-}
 
@@ -511,7 +511,7 @@ petTagsL f Pet{..} = (\petTags -> Pet { petTags, ..} ) <$> f petTags
 {-# INLINE petTagsL #-}
 
 -- | 'petStatus' Lens
-petStatusL :: Lens_' Pet (Maybe Text)
+petStatusL :: Lens_' Pet (Maybe E'Status2)
 petStatusL f Pet{..} = (\petStatus -> Pet { petStatus, ..} ) <$> f petStatus
 {-# INLINE petStatusL #-}