    {-
       OpenAPI Petstore

       This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\

       OpenAPI Version: 3.0.1
       OpenAPI Petstore API version: 1.0.0
       Generated by OpenAPI Generator (https://openapi-generator.tech)
    -}

    {-|
    Module : OpenAPIPetstore.Model
    -}

    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveFoldable #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE DeriveTraversable #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE LambdaCase #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE NamedFieldPuns #-}
    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE RecordWildCards #-}
    {-# LANGUAGE TupleSections #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# OPTIONS_GHC -fno-warn-unused-matches -fno-warn-unused-binds -fno-warn-unused-imports #-}

    module OpenAPIPetstore.Model where

    import OpenAPIPetstore.Core
    import OpenAPIPetstore.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.Base64 as B64
    import qualified Data.ByteString.Char8 as BC
    import qualified Data.ByteString.Lazy as BL
    import qualified Data.Data as P (Typeable, TypeRep, typeOf, typeRep)
    import qualified Data.Foldable as P
    import qualified Data.HashMap.Lazy as HM
    import qualified Data.Map as Map
    import qualified Data.Maybe as P
    import qualified Data.Set as Set
    import qualified Data.Text as T
    import qualified Data.Text.Encoding as T
    import qualified Data.Time as TI
    import qualified Lens.Micro as L
    import qualified Web.FormUrlEncoded as WH
    import qualified Web.HttpApiData as WH

    import Control.Applicative ((<|>))
    import Control.Applicative (Alternative)
    import Data.Function ((&))
    import Data.Monoid ((<>))
    import Data.Text (Text)
    import Prelude (($),(/=),(.),(<$>),(<*>),(>>=),(=<<),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)

    import qualified Prelude as P

    -- * Parameter newtypes

    -- ** AdditionalMetadata
    newtype AdditionalMetadata = AdditionalMetadata { AdditionalMetadata -> Text
    unAdditionalMetadata :: Text } deriving (AdditionalMetadata -> AdditionalMetadata -> Bool
    (AdditionalMetadata -> AdditionalMetadata -> Bool)
    -> (AdditionalMetadata -> AdditionalMetadata -> Bool)
    -> Eq AdditionalMetadata
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditionalMetadata -> AdditionalMetadata -> Bool
    == :: AdditionalMetadata -> AdditionalMetadata -> Bool
    $c/= :: AdditionalMetadata -> AdditionalMetadata -> Bool
    /= :: AdditionalMetadata -> AdditionalMetadata -> Bool
    P.Eq, Int -> AdditionalMetadata -> ShowS
    [AdditionalMetadata] -> ShowS
    AdditionalMetadata -> [Char]
    (Int -> AdditionalMetadata -> ShowS)
    -> (AdditionalMetadata -> [Char])
    -> ([AdditionalMetadata] -> ShowS)
    -> Show AdditionalMetadata
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditionalMetadata -> ShowS
    showsPrec :: Int -> AdditionalMetadata -> ShowS
    $cshow :: AdditionalMetadata -> [Char]
    show :: AdditionalMetadata -> [Char]
    $cshowList :: [AdditionalMetadata] -> ShowS
    showList :: [AdditionalMetadata] -> ShowS
    P.Show)

    -- ** ApiKey
    newtype ApiKey = ApiKey { ApiKey -> Text
    unApiKey :: Text } deriving (ApiKey -> ApiKey -> Bool
    (ApiKey -> ApiKey -> Bool)
    -> (ApiKey -> ApiKey -> Bool) -> Eq ApiKey
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ApiKey -> ApiKey -> Bool
    == :: ApiKey -> ApiKey -> Bool
    $c/= :: ApiKey -> ApiKey -> Bool
    /= :: ApiKey -> ApiKey -> Bool
    P.Eq, Int -> ApiKey -> ShowS
    [ApiKey] -> ShowS
    ApiKey -> [Char]
    (Int -> ApiKey -> ShowS)
    -> (ApiKey -> [Char]) -> ([ApiKey] -> ShowS) -> Show ApiKey
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ApiKey -> ShowS
    showsPrec :: Int -> ApiKey -> ShowS
    $cshow :: ApiKey -> [Char]
    show :: ApiKey -> [Char]
    $cshowList :: [ApiKey] -> ShowS
    showList :: [ApiKey] -> ShowS
    P.Show)

    -- ** Body
    newtype Body = Body { Body -> [User]
    unBody :: [User] } deriving (Body -> Body -> Bool
    (Body -> Body -> Bool) -> (Body -> Body -> Bool) -> Eq Body
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Body -> Body -> Bool
    == :: Body -> Body -> Bool
    $c/= :: Body -> Body -> Bool
    /= :: Body -> Body -> Bool
    P.Eq, Int -> Body -> ShowS
    [Body] -> ShowS
    Body -> [Char]
    (Int -> Body -> ShowS)
    -> (Body -> [Char]) -> ([Body] -> ShowS) -> Show Body
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Body -> ShowS
    showsPrec :: Int -> Body -> ShowS
    $cshow :: Body -> [Char]
    show :: Body -> [Char]
    $cshowList :: [Body] -> ShowS
    showList :: [Body] -> ShowS
    P.Show, [Body] -> Value
    [Body] -> Encoding
    Body -> Value
    Body -> Encoding
    (Body -> Value)
    -> (Body -> Encoding)
    -> ([Body] -> Value)
    -> ([Body] -> Encoding)
    -> ToJSON Body
    forall a.
    (a -> Value)
    -> (a -> Encoding)
    -> ([a] -> Value)
    -> ([a] -> Encoding)
    -> ToJSON a
    $ctoJSON :: Body -> Value
    toJSON :: Body -> Value
    $ctoEncoding :: Body -> Encoding
    toEncoding :: Body -> Encoding
    $ctoJSONList :: [Body] -> Value
    toJSONList :: [Body] -> Value
    $ctoEncodingList :: [Body] -> Encoding
    toEncodingList :: [Body] -> Encoding
    A.ToJSON)

    -- ** BodyBool
    newtype BodyBool = BodyBool { BodyBool -> Bool
    unBodyBool :: Bool } deriving (BodyBool -> BodyBool -> Bool
    (BodyBool -> BodyBool -> Bool)
    -> (BodyBool -> BodyBool -> Bool) -> Eq BodyBool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BodyBool -> BodyBool -> Bool
    == :: BodyBool -> BodyBool -> Bool
    $c/= :: BodyBool -> BodyBool -> Bool
    /= :: BodyBool -> BodyBool -> Bool
    P.Eq, Int -> BodyBool -> ShowS
    [BodyBool] -> ShowS
    BodyBool -> [Char]
    (Int -> BodyBool -> ShowS)
    -> (BodyBool -> [Char]) -> ([BodyBool] -> ShowS) -> Show BodyBool
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BodyBool -> ShowS
    showsPrec :: Int -> BodyBool -> ShowS
    $cshow :: BodyBool -> [Char]
    show :: BodyBool -> [Char]
    $cshowList :: [BodyBool] -> ShowS
    showList :: [BodyBool] -> ShowS
    P.Show, [BodyBool] -> Value
    [BodyBool] -> Encoding
    BodyBool -> Value
    BodyBool -> Encoding
    (BodyBool -> Value)
    -> (BodyBool -> Encoding)
    -> ([BodyBool] -> Value)
    -> ([BodyBool] -> Encoding)
    -> ToJSON BodyBool
    forall a.
    (a -> Value)
    -> (a -> Encoding)
    -> ([a] -> Value)
    -> ([a] -> Encoding)
    -> ToJSON a
    $ctoJSON :: BodyBool -> Value
    toJSON :: BodyBool -> Value
    $ctoEncoding :: BodyBool -> Encoding
    toEncoding :: BodyBool -> Encoding
    $ctoJSONList :: [BodyBool] -> Value
    toJSONList :: [BodyBool] -> Value
    $ctoEncodingList :: [BodyBool] -> Encoding
    toEncodingList :: [BodyBool] -> Encoding
    A.ToJSON)

    -- ** BodyDouble
    newtype BodyDouble = BodyDouble { BodyDouble -> Double
    unBodyDouble :: Double } deriving (BodyDouble -> BodyDouble -> Bool
    (BodyDouble -> BodyDouble -> Bool)
    -> (BodyDouble -> BodyDouble -> Bool) -> Eq BodyDouble
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BodyDouble -> BodyDouble -> Bool
    == :: BodyDouble -> BodyDouble -> Bool
    $c/= :: BodyDouble -> BodyDouble -> Bool
    /= :: BodyDouble -> BodyDouble -> Bool
    P.Eq, Int -> BodyDouble -> ShowS
    [BodyDouble] -> ShowS
    BodyDouble -> [Char]
    (Int -> BodyDouble -> ShowS)
    -> (BodyDouble -> [Char])
    -> ([BodyDouble] -> ShowS)
    -> Show BodyDouble
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BodyDouble -> ShowS
    showsPrec :: Int -> BodyDouble -> ShowS
    $cshow :: BodyDouble -> [Char]
    show :: BodyDouble -> [Char]
    $cshowList :: [BodyDouble] -> ShowS
    showList :: [BodyDouble] -> ShowS
    P.Show, [BodyDouble] -> Value
    [BodyDouble] -> Encoding
    BodyDouble -> Value
    BodyDouble -> Encoding
    (BodyDouble -> Value)
    -> (BodyDouble -> Encoding)
    -> ([BodyDouble] -> Value)
    -> ([BodyDouble] -> Encoding)
    -> ToJSON BodyDouble
    forall a.
    (a -> Value)
    -> (a -> Encoding)
    -> ([a] -> Value)
    -> ([a] -> Encoding)
    -> ToJSON a
    $ctoJSON :: BodyDouble -> Value
    toJSON :: BodyDouble -> Value
    $ctoEncoding :: BodyDouble -> Encoding
    toEncoding :: BodyDouble -> Encoding
    $ctoJSONList :: [BodyDouble] -> Value
    toJSONList :: [BodyDouble] -> Value
    $ctoEncodingList :: [BodyDouble] -> Encoding
    toEncodingList :: [BodyDouble] -> Encoding
    A.ToJSON)

    -- ** BodyText
    newtype BodyText = BodyText { BodyText -> Text
    unBodyText :: Text } deriving (BodyText -> BodyText -> Bool
    (BodyText -> BodyText -> Bool)
    -> (BodyText -> BodyText -> Bool) -> Eq BodyText
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BodyText -> BodyText -> Bool
    == :: BodyText -> BodyText -> Bool
    $c/= :: BodyText -> BodyText -> Bool
    /= :: BodyText -> BodyText -> Bool
    P.Eq, Int -> BodyText -> ShowS
    [BodyText] -> ShowS
    BodyText -> [Char]
    (Int -> BodyText -> ShowS)
    -> (BodyText -> [Char]) -> ([BodyText] -> ShowS) -> Show BodyText
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BodyText -> ShowS
    showsPrec :: Int -> BodyText -> ShowS
    $cshow :: BodyText -> [Char]
    show :: BodyText -> [Char]
    $cshowList :: [BodyText] -> ShowS
    showList :: [BodyText] -> ShowS
    P.Show, [BodyText] -> Value
    [BodyText] -> Encoding
    BodyText -> Value
    BodyText -> Encoding
    (BodyText -> Value)
    -> (BodyText -> Encoding)
    -> ([BodyText] -> Value)
    -> ([BodyText] -> Encoding)
    -> ToJSON BodyText
    forall a.
    (a -> Value)
    -> (a -> Encoding)
    -> ([a] -> Value)
    -> ([a] -> Encoding)
    -> ToJSON a
    $ctoJSON :: BodyText -> Value
    toJSON :: BodyText -> Value
    $ctoEncoding :: BodyText -> Encoding
    toEncoding :: BodyText -> Encoding
    $ctoJSONList :: [BodyText] -> Value
    toJSONList :: [BodyText] -> Value
    $ctoEncodingList :: [BodyText] -> Encoding
    toEncodingList :: [BodyText] -> Encoding
    A.ToJSON)

    -- ** BooleanGroup
    newtype BooleanGroup = BooleanGroup { BooleanGroup -> Bool
    unBooleanGroup :: Bool } deriving (BooleanGroup -> BooleanGroup -> Bool
    (BooleanGroup -> BooleanGroup -> Bool)
    -> (BooleanGroup -> BooleanGroup -> Bool) -> Eq BooleanGroup
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BooleanGroup -> BooleanGroup -> Bool
    == :: BooleanGroup -> BooleanGroup -> Bool
    $c/= :: BooleanGroup -> BooleanGroup -> Bool
    /= :: BooleanGroup -> BooleanGroup -> Bool
    P.Eq, Int -> BooleanGroup -> ShowS
    [BooleanGroup] -> ShowS
    BooleanGroup -> [Char]
    (Int -> BooleanGroup -> ShowS)
    -> (BooleanGroup -> [Char])
    -> ([BooleanGroup] -> ShowS)
    -> Show BooleanGroup
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BooleanGroup -> ShowS
    showsPrec :: Int -> BooleanGroup -> ShowS
    $cshow :: BooleanGroup -> [Char]
    show :: BooleanGroup -> [Char]
    $cshowList :: [BooleanGroup] -> ShowS
    showList :: [BooleanGroup] -> ShowS
    P.Show)

    -- ** Byte
    newtype Byte = Byte { Byte -> ByteArray
    unByte :: ByteArray } deriving (Byte -> Byte -> Bool
    (Byte -> Byte -> Bool) -> (Byte -> Byte -> Bool) -> Eq Byte
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Byte -> Byte -> Bool
    == :: Byte -> Byte -> Bool
    $c/= :: Byte -> Byte -> Bool
    /= :: Byte -> Byte -> Bool
    P.Eq, Int -> Byte -> ShowS
    [Byte] -> ShowS
    Byte -> [Char]
    (Int -> Byte -> ShowS)
    -> (Byte -> [Char]) -> ([Byte] -> ShowS) -> Show Byte
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Byte -> ShowS
    showsPrec :: Int -> Byte -> ShowS
    $cshow :: Byte -> [Char]
    show :: Byte -> [Char]
    $cshowList :: [Byte] -> ShowS
    showList :: [Byte] -> ShowS
    P.Show)

    -- ** Callback
    newtype Callback = Callback { Callback -> Text
    unCallback :: Text } deriving (Callback -> Callback -> Bool
    (Callback -> Callback -> Bool)
    -> (Callback -> Callback -> Bool) -> Eq Callback
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Callback -> Callback -> Bool
    == :: Callback -> Callback -> Bool
    $c/= :: Callback -> Callback -> Bool
    /= :: Callback -> Callback -> Bool
    P.Eq, Int -> Callback -> ShowS
    [Callback] -> ShowS
    Callback -> [Char]
    (Int -> Callback -> ShowS)
    -> (Callback -> [Char]) -> ([Callback] -> ShowS) -> Show Callback
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Callback -> ShowS
    showsPrec :: Int -> Callback -> ShowS
    $cshow :: Callback -> [Char]
    show :: Callback -> [Char]
    $cshowList :: [Callback] -> ShowS
    showList :: [Callback] -> ShowS
    P.Show)

    -- ** Context
    newtype Context = Context { Context -> [Text]
    unContext :: [Text] } deriving (Context -> Context -> Bool
    (Context -> Context -> Bool)
    -> (Context -> Context -> Bool) -> Eq Context
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Context -> Context -> Bool
    == :: Context -> Context -> Bool
    $c/= :: Context -> Context -> Bool
    /= :: Context -> Context -> Bool
    P.Eq, Int -> Context -> ShowS
    [Context] -> ShowS
    Context -> [Char]
    (Int -> Context -> ShowS)
    -> (Context -> [Char]) -> ([Context] -> ShowS) -> Show Context
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Context -> ShowS
    showsPrec :: Int -> Context -> ShowS
    $cshow :: Context -> [Char]
    show :: Context -> [Char]
    $cshowList :: [Context] -> ShowS
    showList :: [Context] -> ShowS
    P.Show)

    -- ** EnumFormString
    newtype EnumFormString = EnumFormString { EnumFormString -> E'EnumFormString
    unEnumFormString :: E'EnumFormString } deriving (EnumFormString -> EnumFormString -> Bool
    (EnumFormString -> EnumFormString -> Bool)
    -> (EnumFormString -> EnumFormString -> Bool) -> Eq EnumFormString
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumFormString -> EnumFormString -> Bool
    == :: EnumFormString -> EnumFormString -> Bool
    $c/= :: EnumFormString -> EnumFormString -> Bool
    /= :: EnumFormString -> EnumFormString -> Bool
    P.Eq, Int -> EnumFormString -> ShowS
    [EnumFormString] -> ShowS
    EnumFormString -> [Char]
    (Int -> EnumFormString -> ShowS)
    -> (EnumFormString -> [Char])
    -> ([EnumFormString] -> ShowS)
    -> Show EnumFormString
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumFormString -> ShowS
    showsPrec :: Int -> EnumFormString -> ShowS
    $cshow :: EnumFormString -> [Char]
    show :: EnumFormString -> [Char]
    $cshowList :: [EnumFormString] -> ShowS
    showList :: [EnumFormString] -> ShowS
    P.Show)

    -- ** EnumFormStringArray
    newtype EnumFormStringArray = EnumFormStringArray { EnumFormStringArray -> [E'EnumFormStringArray]
    unEnumFormStringArray :: [E'EnumFormStringArray] } deriving (EnumFormStringArray -> EnumFormStringArray -> Bool
    (EnumFormStringArray -> EnumFormStringArray -> Bool)
    -> (EnumFormStringArray -> EnumFormStringArray -> Bool)
    -> Eq EnumFormStringArray
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumFormStringArray -> EnumFormStringArray -> Bool
    == :: EnumFormStringArray -> EnumFormStringArray -> Bool
    $c/= :: EnumFormStringArray -> EnumFormStringArray -> Bool
    /= :: EnumFormStringArray -> EnumFormStringArray -> Bool
    P.Eq, Int -> EnumFormStringArray -> ShowS
    [EnumFormStringArray] -> ShowS
    EnumFormStringArray -> [Char]
    (Int -> EnumFormStringArray -> ShowS)
    -> (EnumFormStringArray -> [Char])
    -> ([EnumFormStringArray] -> ShowS)
    -> Show EnumFormStringArray
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumFormStringArray -> ShowS
    showsPrec :: Int -> EnumFormStringArray -> ShowS
    $cshow :: EnumFormStringArray -> [Char]
    show :: EnumFormStringArray -> [Char]
    $cshowList :: [EnumFormStringArray] -> ShowS
    showList :: [EnumFormStringArray] -> ShowS
    P.Show)

    -- ** EnumHeaderString
    newtype EnumHeaderString = EnumHeaderString { EnumHeaderString -> E'EnumFormString
    unEnumHeaderString :: E'EnumFormString } deriving (EnumHeaderString -> EnumHeaderString -> Bool
    (EnumHeaderString -> EnumHeaderString -> Bool)
    -> (EnumHeaderString -> EnumHeaderString -> Bool)
    -> Eq EnumHeaderString
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumHeaderString -> EnumHeaderString -> Bool
    == :: EnumHeaderString -> EnumHeaderString -> Bool
    $c/= :: EnumHeaderString -> EnumHeaderString -> Bool
    /= :: EnumHeaderString -> EnumHeaderString -> Bool
    P.Eq, Int -> EnumHeaderString -> ShowS
    [EnumHeaderString] -> ShowS
    EnumHeaderString -> [Char]
    (Int -> EnumHeaderString -> ShowS)
    -> (EnumHeaderString -> [Char])
    -> ([EnumHeaderString] -> ShowS)
    -> Show EnumHeaderString
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumHeaderString -> ShowS
    showsPrec :: Int -> EnumHeaderString -> ShowS
    $cshow :: EnumHeaderString -> [Char]
    show :: EnumHeaderString -> [Char]
    $cshowList :: [EnumHeaderString] -> ShowS
    showList :: [EnumHeaderString] -> ShowS
    P.Show)

    -- ** EnumHeaderStringArray
    newtype EnumHeaderStringArray = EnumHeaderStringArray { EnumHeaderStringArray -> [E'EnumFormStringArray]
    unEnumHeaderStringArray :: [E'EnumFormStringArray] } deriving (EnumHeaderStringArray -> EnumHeaderStringArray -> Bool
    (EnumHeaderStringArray -> EnumHeaderStringArray -> Bool)
    -> (EnumHeaderStringArray -> EnumHeaderStringArray -> Bool)
    -> Eq EnumHeaderStringArray
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumHeaderStringArray -> EnumHeaderStringArray -> Bool
    == :: EnumHeaderStringArray -> EnumHeaderStringArray -> Bool
    $c/= :: EnumHeaderStringArray -> EnumHeaderStringArray -> Bool
    /= :: EnumHeaderStringArray -> EnumHeaderStringArray -> Bool
    P.Eq, Int -> EnumHeaderStringArray -> ShowS
    [EnumHeaderStringArray] -> ShowS
    EnumHeaderStringArray -> [Char]
    (Int -> EnumHeaderStringArray -> ShowS)
    -> (EnumHeaderStringArray -> [Char])
    -> ([EnumHeaderStringArray] -> ShowS)
    -> Show EnumHeaderStringArray
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumHeaderStringArray -> ShowS
    showsPrec :: Int -> EnumHeaderStringArray -> ShowS
    $cshow :: EnumHeaderStringArray -> [Char]
    show :: EnumHeaderStringArray -> [Char]
    $cshowList :: [EnumHeaderStringArray] -> ShowS
    showList :: [EnumHeaderStringArray] -> ShowS
    P.Show)

    -- ** EnumQueryDouble
    newtype EnumQueryDouble = EnumQueryDouble { EnumQueryDouble -> E'EnumNumber
    unEnumQueryDouble :: E'EnumNumber } deriving (EnumQueryDouble -> EnumQueryDouble -> Bool
    (EnumQueryDouble -> EnumQueryDouble -> Bool)
    -> (EnumQueryDouble -> EnumQueryDouble -> Bool)
    -> Eq EnumQueryDouble
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumQueryDouble -> EnumQueryDouble -> Bool
    == :: EnumQueryDouble -> EnumQueryDouble -> Bool
    $c/= :: EnumQueryDouble -> EnumQueryDouble -> Bool
    /= :: EnumQueryDouble -> EnumQueryDouble -> Bool
    P.Eq, Int -> EnumQueryDouble -> ShowS
    [EnumQueryDouble] -> ShowS
    EnumQueryDouble -> [Char]
    (Int -> EnumQueryDouble -> ShowS)
    -> (EnumQueryDouble -> [Char])
    -> ([EnumQueryDouble] -> ShowS)
    -> Show EnumQueryDouble
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumQueryDouble -> ShowS
    showsPrec :: Int -> EnumQueryDouble -> ShowS
    $cshow :: EnumQueryDouble -> [Char]
    show :: EnumQueryDouble -> [Char]
    $cshowList :: [EnumQueryDouble] -> ShowS
    showList :: [EnumQueryDouble] -> ShowS
    P.Show)

    -- ** EnumQueryInteger
    newtype EnumQueryInteger = EnumQueryInteger { EnumQueryInteger -> E'EnumQueryInteger
    unEnumQueryInteger :: E'EnumQueryInteger } deriving (EnumQueryInteger -> EnumQueryInteger -> Bool
    (EnumQueryInteger -> EnumQueryInteger -> Bool)
    -> (EnumQueryInteger -> EnumQueryInteger -> Bool)
    -> Eq EnumQueryInteger
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumQueryInteger -> EnumQueryInteger -> Bool
    == :: EnumQueryInteger -> EnumQueryInteger -> Bool
    $c/= :: EnumQueryInteger -> EnumQueryInteger -> Bool
    /= :: EnumQueryInteger -> EnumQueryInteger -> Bool
    P.Eq, Int -> EnumQueryInteger -> ShowS
    [EnumQueryInteger] -> ShowS
    EnumQueryInteger -> [Char]
    (Int -> EnumQueryInteger -> ShowS)
    -> (EnumQueryInteger -> [Char])
    -> ([EnumQueryInteger] -> ShowS)
    -> Show EnumQueryInteger
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumQueryInteger -> ShowS
    showsPrec :: Int -> EnumQueryInteger -> ShowS
    $cshow :: EnumQueryInteger -> [Char]
    show :: EnumQueryInteger -> [Char]
    $cshowList :: [EnumQueryInteger] -> ShowS
    showList :: [EnumQueryInteger] -> ShowS
    P.Show)

    -- ** EnumQueryString
    newtype EnumQueryString = EnumQueryString { EnumQueryString -> E'EnumFormString
    unEnumQueryString :: E'EnumFormString } deriving (EnumQueryString -> EnumQueryString -> Bool
    (EnumQueryString -> EnumQueryString -> Bool)
    -> (EnumQueryString -> EnumQueryString -> Bool)
    -> Eq EnumQueryString
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumQueryString -> EnumQueryString -> Bool
    == :: EnumQueryString -> EnumQueryString -> Bool
    $c/= :: EnumQueryString -> EnumQueryString -> Bool
    /= :: EnumQueryString -> EnumQueryString -> Bool
    P.Eq, Int -> EnumQueryString -> ShowS
    [EnumQueryString] -> ShowS
    EnumQueryString -> [Char]
    (Int -> EnumQueryString -> ShowS)
    -> (EnumQueryString -> [Char])
    -> ([EnumQueryString] -> ShowS)
    -> Show EnumQueryString
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumQueryString -> ShowS
    showsPrec :: Int -> EnumQueryString -> ShowS
    $cshow :: EnumQueryString -> [Char]
    show :: EnumQueryString -> [Char]
    $cshowList :: [EnumQueryString] -> ShowS
    showList :: [EnumQueryString] -> ShowS
    P.Show)

    -- ** EnumQueryStringArray
    newtype EnumQueryStringArray = EnumQueryStringArray { EnumQueryStringArray -> [E'EnumFormStringArray]
    unEnumQueryStringArray :: [E'EnumFormStringArray] } deriving (EnumQueryStringArray -> EnumQueryStringArray -> Bool
    (EnumQueryStringArray -> EnumQueryStringArray -> Bool)
    -> (EnumQueryStringArray -> EnumQueryStringArray -> Bool)
    -> Eq EnumQueryStringArray
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumQueryStringArray -> EnumQueryStringArray -> Bool
    == :: EnumQueryStringArray -> EnumQueryStringArray -> Bool
    $c/= :: EnumQueryStringArray -> EnumQueryStringArray -> Bool
    /= :: EnumQueryStringArray -> EnumQueryStringArray -> Bool
    P.Eq, Int -> EnumQueryStringArray -> ShowS
    [EnumQueryStringArray] -> ShowS
    EnumQueryStringArray -> [Char]
    (Int -> EnumQueryStringArray -> ShowS)
    -> (EnumQueryStringArray -> [Char])
    -> ([EnumQueryStringArray] -> ShowS)
    -> Show EnumQueryStringArray
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumQueryStringArray -> ShowS
    showsPrec :: Int -> EnumQueryStringArray -> ShowS
    $cshow :: EnumQueryStringArray -> [Char]
    show :: EnumQueryStringArray -> [Char]
    $cshowList :: [EnumQueryStringArray] -> ShowS
    showList :: [EnumQueryStringArray] -> ShowS
    P.Show)

    -- ** File2
    newtype File2 = File2 { File2 -> [Char]
    unFile2 :: FilePath } deriving (File2 -> File2 -> Bool
    (File2 -> File2 -> Bool) -> (File2 -> File2 -> Bool) -> Eq File2
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: File2 -> File2 -> Bool
    == :: File2 -> File2 -> Bool
    $c/= :: File2 -> File2 -> Bool
    /= :: File2 -> File2 -> Bool
    P.Eq, Int -> File2 -> ShowS
    [File2] -> ShowS
    File2 -> [Char]
    (Int -> File2 -> ShowS)
    -> (File2 -> [Char]) -> ([File2] -> ShowS) -> Show File2
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> File2 -> ShowS
    showsPrec :: Int -> File2 -> ShowS
    $cshow :: File2 -> [Char]
    show :: File2 -> [Char]
    $cshowList :: [File2] -> ShowS
    showList :: [File2] -> ShowS
    P.Show)

    -- ** Http
    newtype Http = Http { Http -> [Text]
    unHttp :: [Text] } deriving (Http -> Http -> Bool
    (Http -> Http -> Bool) -> (Http -> Http -> Bool) -> Eq Http
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Http -> Http -> Bool
    == :: Http -> Http -> Bool
    $c/= :: Http -> Http -> Bool
    /= :: Http -> Http -> Bool
    P.Eq, Int -> Http -> ShowS
    [Http] -> ShowS
    Http -> [Char]
    (Int -> Http -> ShowS)
    -> (Http -> [Char]) -> ([Http] -> ShowS) -> Show Http
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Http -> ShowS
    showsPrec :: Int -> Http -> ShowS
    $cshow :: Http -> [Char]
    show :: Http -> [Char]
    $cshowList :: [Http] -> ShowS
    showList :: [Http] -> ShowS
    P.Show)

    -- ** Int32
    newtype Int32 = Int32 { Int32 -> Int
    unInt32 :: Int } deriving (Int32 -> Int32 -> Bool
    (Int32 -> Int32 -> Bool) -> (Int32 -> Int32 -> Bool) -> Eq Int32
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Int32 -> Int32 -> Bool
    == :: Int32 -> Int32 -> Bool
    $c/= :: Int32 -> Int32 -> Bool
    /= :: Int32 -> Int32 -> Bool
    P.Eq, Int -> Int32 -> ShowS
    [Int32] -> ShowS
    Int32 -> [Char]
    (Int -> Int32 -> ShowS)
    -> (Int32 -> [Char]) -> ([Int32] -> ShowS) -> Show Int32
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Int32 -> ShowS
    showsPrec :: Int -> Int32 -> ShowS
    $cshow :: Int32 -> [Char]
    show :: Int32 -> [Char]
    $cshowList :: [Int32] -> ShowS
    showList :: [Int32] -> ShowS
    P.Show)

    -- ** Int64
    newtype Int64 = Int64 { Int64 -> Integer
    unInt64 :: Integer } deriving (Int64 -> Int64 -> Bool
    (Int64 -> Int64 -> Bool) -> (Int64 -> Int64 -> Bool) -> Eq Int64
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Int64 -> Int64 -> Bool
    == :: Int64 -> Int64 -> Bool
    $c/= :: Int64 -> Int64 -> Bool
    /= :: Int64 -> Int64 -> Bool
    P.Eq, Int -> Int64 -> ShowS
    [Int64] -> ShowS
    Int64 -> [Char]
    (Int -> Int64 -> ShowS)
    -> (Int64 -> [Char]) -> ([Int64] -> ShowS) -> Show Int64
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Int64 -> ShowS
    showsPrec :: Int -> Int64 -> ShowS
    $cshow :: Int64 -> [Char]
    show :: Int64 -> [Char]
    $cshowList :: [Int64] -> ShowS
    showList :: [Int64] -> ShowS
    P.Show)

    -- ** Int64Group
    newtype Int64Group = Int64Group { Int64Group -> Integer
    unInt64Group :: Integer } deriving (Int64Group -> Int64Group -> Bool
    (Int64Group -> Int64Group -> Bool)
    -> (Int64Group -> Int64Group -> Bool) -> Eq Int64Group
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Int64Group -> Int64Group -> Bool
    == :: Int64Group -> Int64Group -> Bool
    $c/= :: Int64Group -> Int64Group -> Bool
    /= :: Int64Group -> Int64Group -> Bool
    P.Eq, Int -> Int64Group -> ShowS
    [Int64Group] -> ShowS
    Int64Group -> [Char]
    (Int -> Int64Group -> ShowS)
    -> (Int64Group -> [Char])
    -> ([Int64Group] -> ShowS)
    -> Show Int64Group
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Int64Group -> ShowS
    showsPrec :: Int -> Int64Group -> ShowS
    $cshow :: Int64Group -> [Char]
    show :: Int64Group -> [Char]
    $cshowList :: [Int64Group] -> ShowS
    showList :: [Int64Group] -> ShowS
    P.Show)

    -- ** Ioutil
    newtype Ioutil = Ioutil { Ioutil -> [Text]
    unIoutil :: [Text] } deriving (Ioutil -> Ioutil -> Bool
    (Ioutil -> Ioutil -> Bool)
    -> (Ioutil -> Ioutil -> Bool) -> Eq Ioutil
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Ioutil -> Ioutil -> Bool
    == :: Ioutil -> Ioutil -> Bool
    $c/= :: Ioutil -> Ioutil -> Bool
    /= :: Ioutil -> Ioutil -> Bool
    P.Eq, Int -> Ioutil -> ShowS
    [Ioutil] -> ShowS
    Ioutil -> [Char]
    (Int -> Ioutil -> ShowS)
    -> (Ioutil -> [Char]) -> ([Ioutil] -> ShowS) -> Show Ioutil
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Ioutil -> ShowS
    showsPrec :: Int -> Ioutil -> ShowS
    $cshow :: Ioutil -> [Char]
    show :: Ioutil -> [Char]
    $cshowList :: [Ioutil] -> ShowS
    showList :: [Ioutil] -> ShowS
    P.Show)

    -- ** Name2
    newtype Name2 = Name2 { Name2 -> Text
    unName2 :: Text } deriving (Name2 -> Name2 -> Bool
    (Name2 -> Name2 -> Bool) -> (Name2 -> Name2 -> Bool) -> Eq Name2
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Name2 -> Name2 -> Bool
    == :: Name2 -> Name2 -> Bool
    $c/= :: Name2 -> Name2 -> Bool
    /= :: Name2 -> Name2 -> Bool
    P.Eq, Int -> Name2 -> ShowS
    [Name2] -> ShowS
    Name2 -> [Char]
    (Int -> Name2 -> ShowS)
    -> (Name2 -> [Char]) -> ([Name2] -> ShowS) -> Show Name2
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Name2 -> ShowS
    showsPrec :: Int -> Name2 -> ShowS
    $cshow :: Name2 -> [Char]
    show :: Name2 -> [Char]
    $cshowList :: [Name2] -> ShowS
    showList :: [Name2] -> ShowS
    P.Show)

    -- ** Number
    newtype Number = Number { Number -> Double
    unNumber :: Double } deriving (Number -> Number -> Bool
    (Number -> Number -> Bool)
    -> (Number -> Number -> Bool) -> Eq Number
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Number -> Number -> Bool
    == :: Number -> Number -> Bool
    $c/= :: Number -> Number -> Bool
    /= :: Number -> Number -> Bool
    P.Eq, Int -> Number -> ShowS
    [Number] -> ShowS
    Number -> [Char]
    (Int -> Number -> ShowS)
    -> (Number -> [Char]) -> ([Number] -> ShowS) -> Show Number
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Number -> ShowS
    showsPrec :: Int -> Number -> ShowS
    $cshow :: Number -> [Char]
    show :: Number -> [Char]
    $cshowList :: [Number] -> ShowS
    showList :: [Number] -> ShowS
    P.Show)

    -- ** OrderId
    newtype OrderId = OrderId { OrderId -> Integer
    unOrderId :: Integer } deriving (OrderId -> OrderId -> Bool
    (OrderId -> OrderId -> Bool)
    -> (OrderId -> OrderId -> Bool) -> Eq OrderId
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OrderId -> OrderId -> Bool
    == :: OrderId -> OrderId -> Bool
    $c/= :: OrderId -> OrderId -> Bool
    /= :: OrderId -> OrderId -> Bool
    P.Eq, Int -> OrderId -> ShowS
    [OrderId] -> ShowS
    OrderId -> [Char]
    (Int -> OrderId -> ShowS)
    -> (OrderId -> [Char]) -> ([OrderId] -> ShowS) -> Show OrderId
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OrderId -> ShowS
    showsPrec :: Int -> OrderId -> ShowS
    $cshow :: OrderId -> [Char]
    show :: OrderId -> [Char]
    $cshowList :: [OrderId] -> ShowS
    showList :: [OrderId] -> ShowS
    P.Show)

    -- ** OrderIdText
    newtype OrderIdText = OrderIdText { OrderIdText -> Text
    unOrderIdText :: Text } deriving (OrderIdText -> OrderIdText -> Bool
    (OrderIdText -> OrderIdText -> Bool)
    -> (OrderIdText -> OrderIdText -> Bool) -> Eq OrderIdText
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OrderIdText -> OrderIdText -> Bool
    == :: OrderIdText -> OrderIdText -> Bool
    $c/= :: OrderIdText -> OrderIdText -> Bool
    /= :: OrderIdText -> OrderIdText -> Bool
    P.Eq, Int -> OrderIdText -> ShowS
    [OrderIdText] -> ShowS
    OrderIdText -> [Char]
    (Int -> OrderIdText -> ShowS)
    -> (OrderIdText -> [Char])
    -> ([OrderIdText] -> ShowS)
    -> Show OrderIdText
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OrderIdText -> ShowS
    showsPrec :: Int -> OrderIdText -> ShowS
    $cshow :: OrderIdText -> [Char]
    show :: OrderIdText -> [Char]
    $cshowList :: [OrderIdText] -> ShowS
    showList :: [OrderIdText] -> ShowS
    P.Show)

    -- ** Param
    newtype Param = Param { Param -> Text
    unParam :: Text } deriving (Param -> Param -> Bool
    (Param -> Param -> Bool) -> (Param -> Param -> Bool) -> Eq Param
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Param -> Param -> Bool
    == :: Param -> Param -> Bool
    $c/= :: Param -> Param -> Bool
    /= :: Param -> Param -> Bool
    P.Eq, Int -> Param -> ShowS
    [Param] -> ShowS
    Param -> [Char]
    (Int -> Param -> ShowS)
    -> (Param -> [Char]) -> ([Param] -> ShowS) -> Show Param
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Param -> ShowS
    showsPrec :: Int -> Param -> ShowS
    $cshow :: Param -> [Char]
    show :: Param -> [Char]
    $cshowList :: [Param] -> ShowS
    showList :: [Param] -> ShowS
    P.Show)

    -- ** Param2
    newtype Param2 = Param2 { Param2 -> Text
    unParam2 :: Text } deriving (Param2 -> Param2 -> Bool
    (Param2 -> Param2 -> Bool)
    -> (Param2 -> Param2 -> Bool) -> Eq Param2
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Param2 -> Param2 -> Bool
    == :: Param2 -> Param2 -> Bool
    $c/= :: Param2 -> Param2 -> Bool
    /= :: Param2 -> Param2 -> Bool
    P.Eq, Int -> Param2 -> ShowS
    [Param2] -> ShowS
    Param2 -> [Char]
    (Int -> Param2 -> ShowS)
    -> (Param2 -> [Char]) -> ([Param2] -> ShowS) -> Show Param2
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Param2 -> ShowS
    showsPrec :: Int -> Param2 -> ShowS
    $cshow :: Param2 -> [Char]
    show :: Param2 -> [Char]
    $cshowList :: [Param2] -> ShowS
    showList :: [Param2] -> ShowS
    P.Show)

    -- ** ParamBinary
    newtype ParamBinary = ParamBinary { ParamBinary -> [Char]
    unParamBinary :: FilePath } deriving (ParamBinary -> ParamBinary -> Bool
    (ParamBinary -> ParamBinary -> Bool)
    -> (ParamBinary -> ParamBinary -> Bool) -> Eq ParamBinary
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ParamBinary -> ParamBinary -> Bool
    == :: ParamBinary -> ParamBinary -> Bool
    $c/= :: ParamBinary -> ParamBinary -> Bool
    /= :: ParamBinary -> ParamBinary -> Bool
    P.Eq, Int -> ParamBinary -> ShowS
    [ParamBinary] -> ShowS
    ParamBinary -> [Char]
    (Int -> ParamBinary -> ShowS)
    -> (ParamBinary -> [Char])
    -> ([ParamBinary] -> ShowS)
    -> Show ParamBinary
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ParamBinary -> ShowS
    showsPrec :: Int -> ParamBinary -> ShowS
    $cshow :: ParamBinary -> [Char]
    show :: ParamBinary -> [Char]
    $cshowList :: [ParamBinary] -> ShowS
    showList :: [ParamBinary] -> ShowS
    P.Show)

    -- ** ParamDate
    newtype ParamDate = ParamDate { ParamDate -> Date
    unParamDate :: Date } deriving (ParamDate -> ParamDate -> Bool
    (ParamDate -> ParamDate -> Bool)
    -> (ParamDate -> ParamDate -> Bool) -> Eq ParamDate
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ParamDate -> ParamDate -> Bool
    == :: ParamDate -> ParamDate -> Bool
    $c/= :: ParamDate -> ParamDate -> Bool
    /= :: ParamDate -> ParamDate -> Bool
    P.Eq, Int -> ParamDate -> ShowS
    [ParamDate] -> ShowS
    ParamDate -> [Char]
    (Int -> ParamDate -> ShowS)
    -> (ParamDate -> [Char])
    -> ([ParamDate] -> ShowS)
    -> Show ParamDate
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ParamDate -> ShowS
    showsPrec :: Int -> ParamDate -> ShowS
    $cshow :: ParamDate -> [Char]
    show :: ParamDate -> [Char]
    $cshowList :: [ParamDate] -> ShowS
    showList :: [ParamDate] -> ShowS
    P.Show)

    -- ** ParamDateTime
    newtype ParamDateTime = ParamDateTime { ParamDateTime -> DateTime
    unParamDateTime :: DateTime } deriving (ParamDateTime -> ParamDateTime -> Bool
    (ParamDateTime -> ParamDateTime -> Bool)
    -> (ParamDateTime -> ParamDateTime -> Bool) -> Eq ParamDateTime
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ParamDateTime -> ParamDateTime -> Bool
    == :: ParamDateTime -> ParamDateTime -> Bool
    $c/= :: ParamDateTime -> ParamDateTime -> Bool
    /= :: ParamDateTime -> ParamDateTime -> Bool
    P.Eq, Int -> ParamDateTime -> ShowS
    [ParamDateTime] -> ShowS
    ParamDateTime -> [Char]
    (Int -> ParamDateTime -> ShowS)
    -> (ParamDateTime -> [Char])
    -> ([ParamDateTime] -> ShowS)
    -> Show ParamDateTime
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ParamDateTime -> ShowS
    showsPrec :: Int -> ParamDateTime -> ShowS
    $cshow :: ParamDateTime -> [Char]
    show :: ParamDateTime -> [Char]
    $cshowList :: [ParamDateTime] -> ShowS
    showList :: [ParamDateTime] -> ShowS
    P.Show)

    -- ** ParamDouble
    newtype ParamDouble = ParamDouble { ParamDouble -> Double
    unParamDouble :: Double } deriving (ParamDouble -> ParamDouble -> Bool
    (ParamDouble -> ParamDouble -> Bool)
    -> (ParamDouble -> ParamDouble -> Bool) -> Eq ParamDouble
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ParamDouble -> ParamDouble -> Bool
    == :: ParamDouble -> ParamDouble -> Bool
    $c/= :: ParamDouble -> ParamDouble -> Bool
    /= :: ParamDouble -> ParamDouble -> Bool
    P.Eq, Int -> ParamDouble -> ShowS
    [ParamDouble] -> ShowS
    ParamDouble -> [Char]
    (Int -> ParamDouble -> ShowS)
    -> (ParamDouble -> [Char])
    -> ([ParamDouble] -> ShowS)
    -> Show ParamDouble
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ParamDouble -> ShowS
    showsPrec :: Int -> ParamDouble -> ShowS
    $cshow :: ParamDouble -> [Char]
    show :: ParamDouble -> [Char]
    $cshowList :: [ParamDouble] -> ShowS
    showList :: [ParamDouble] -> ShowS
    P.Show)

    -- ** ParamFloat
    newtype ParamFloat = ParamFloat { ParamFloat -> Float
    unParamFloat :: Float } deriving (ParamFloat -> ParamFloat -> Bool
    (ParamFloat -> ParamFloat -> Bool)
    -> (ParamFloat -> ParamFloat -> Bool) -> Eq ParamFloat
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ParamFloat -> ParamFloat -> Bool
    == :: ParamFloat -> ParamFloat -> Bool
    $c/= :: ParamFloat -> ParamFloat -> Bool
    /= :: ParamFloat -> ParamFloat -> Bool
    P.Eq, Int -> ParamFloat -> ShowS
    [ParamFloat] -> ShowS
    ParamFloat -> [Char]
    (Int -> ParamFloat -> ShowS)
    -> (ParamFloat -> [Char])
    -> ([ParamFloat] -> ShowS)
    -> Show ParamFloat
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ParamFloat -> ShowS
    showsPrec :: Int -> ParamFloat -> ShowS
    $cshow :: ParamFloat -> [Char]
    show :: ParamFloat -> [Char]
    $cshowList :: [ParamFloat] -> ShowS
    showList :: [ParamFloat] -> ShowS
    P.Show)

    -- ** ParamInteger
    newtype ParamInteger = ParamInteger { ParamInteger -> Int
    unParamInteger :: Int } deriving (ParamInteger -> ParamInteger -> Bool
    (ParamInteger -> ParamInteger -> Bool)
    -> (ParamInteger -> ParamInteger -> Bool) -> Eq ParamInteger
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ParamInteger -> ParamInteger -> Bool
    == :: ParamInteger -> ParamInteger -> Bool
    $c/= :: ParamInteger -> ParamInteger -> Bool
    /= :: ParamInteger -> ParamInteger -> Bool
    P.Eq, Int -> ParamInteger -> ShowS
    [ParamInteger] -> ShowS
    ParamInteger -> [Char]
    (Int -> ParamInteger -> ShowS)
    -> (ParamInteger -> [Char])
    -> ([ParamInteger] -> ShowS)
    -> Show ParamInteger
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ParamInteger -> ShowS
    showsPrec :: Int -> ParamInteger -> ShowS
    $cshow :: ParamInteger -> [Char]
    show :: ParamInteger -> [Char]
    $cshowList :: [ParamInteger] -> ShowS
    showList :: [ParamInteger] -> ShowS
    P.Show)

    -- ** ParamMapMapStringText
    newtype ParamMapMapStringText = ParamMapMapStringText { ParamMapMapStringText -> Map [Char] Text
    unParamMapMapStringText :: (Map.Map String Text) } deriving (ParamMapMapStringText -> ParamMapMapStringText -> Bool
    (ParamMapMapStringText -> ParamMapMapStringText -> Bool)
    -> (ParamMapMapStringText -> ParamMapMapStringText -> Bool)
    -> Eq ParamMapMapStringText
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ParamMapMapStringText -> ParamMapMapStringText -> Bool
    == :: ParamMapMapStringText -> ParamMapMapStringText -> Bool
    $c/= :: ParamMapMapStringText -> ParamMapMapStringText -> Bool
    /= :: ParamMapMapStringText -> ParamMapMapStringText -> Bool
    P.Eq, Int -> ParamMapMapStringText -> ShowS
    [ParamMapMapStringText] -> ShowS
    ParamMapMapStringText -> [Char]
    (Int -> ParamMapMapStringText -> ShowS)
    -> (ParamMapMapStringText -> [Char])
    -> ([ParamMapMapStringText] -> ShowS)
    -> Show ParamMapMapStringText
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ParamMapMapStringText -> ShowS
    showsPrec :: Int -> ParamMapMapStringText -> ShowS
    $cshow :: ParamMapMapStringText -> [Char]
    show :: ParamMapMapStringText -> [Char]
    $cshowList :: [ParamMapMapStringText] -> ShowS
    showList :: [ParamMapMapStringText] -> ShowS
    P.Show, [ParamMapMapStringText] -> Value
    [ParamMapMapStringText] -> Encoding
    ParamMapMapStringText -> Value
    ParamMapMapStringText -> Encoding
    (ParamMapMapStringText -> Value)
    -> (ParamMapMapStringText -> Encoding)
    -> ([ParamMapMapStringText] -> Value)
    -> ([ParamMapMapStringText] -> Encoding)
    -> ToJSON ParamMapMapStringText
    forall a.
    (a -> Value)
    -> (a -> Encoding)
    -> ([a] -> Value)
    -> ([a] -> Encoding)
    -> ToJSON a
    $ctoJSON :: ParamMapMapStringText -> Value
    toJSON :: ParamMapMapStringText -> Value
    $ctoEncoding :: ParamMapMapStringText -> Encoding
    toEncoding :: ParamMapMapStringText -> Encoding
    $ctoJSONList :: [ParamMapMapStringText] -> Value
    toJSONList :: [ParamMapMapStringText] -> Value
    $ctoEncodingList :: [ParamMapMapStringText] -> Encoding
    toEncodingList :: [ParamMapMapStringText] -> Encoding
    A.ToJSON)

    -- ** ParamString
    newtype ParamString = ParamString { ParamString -> Text
    unParamString :: Text } deriving (ParamString -> ParamString -> Bool
    (ParamString -> ParamString -> Bool)
    -> (ParamString -> ParamString -> Bool) -> Eq ParamString
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ParamString -> ParamString -> Bool
    == :: ParamString -> ParamString -> Bool
    $c/= :: ParamString -> ParamString -> Bool
    /= :: ParamString -> ParamString -> Bool
    P.Eq, Int -> ParamString -> ShowS
    [ParamString] -> ShowS
    ParamString -> [Char]
    (Int -> ParamString -> ShowS)
    -> (ParamString -> [Char])
    -> ([ParamString] -> ShowS)
    -> Show ParamString
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ParamString -> ShowS
    showsPrec :: Int -> ParamString -> ShowS
    $cshow :: ParamString -> [Char]
    show :: ParamString -> [Char]
    $cshowList :: [ParamString] -> ShowS
    showList :: [ParamString] -> ShowS
    P.Show)

    -- ** Password
    newtype Password = Password { Password -> Text
    unPassword :: Text } deriving (Password -> Password -> Bool
    (Password -> Password -> Bool)
    -> (Password -> Password -> Bool) -> Eq Password
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Password -> Password -> Bool
    == :: Password -> Password -> Bool
    $c/= :: Password -> Password -> Bool
    /= :: Password -> Password -> Bool
    P.Eq, Int -> Password -> ShowS
    [Password] -> ShowS
    Password -> [Char]
    (Int -> Password -> ShowS)
    -> (Password -> [Char]) -> ([Password] -> ShowS) -> Show Password
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Password -> ShowS
    showsPrec :: Int -> Password -> ShowS
    $cshow :: Password -> [Char]
    show :: Password -> [Char]
    $cshowList :: [Password] -> ShowS
    showList :: [Password] -> ShowS
    P.Show)

    -- ** PatternWithoutDelimiter
    newtype PatternWithoutDelimiter = PatternWithoutDelimiter { PatternWithoutDelimiter -> Text
    unPatternWithoutDelimiter :: Text } deriving (PatternWithoutDelimiter -> PatternWithoutDelimiter -> Bool
    (PatternWithoutDelimiter -> PatternWithoutDelimiter -> Bool)
    -> (PatternWithoutDelimiter -> PatternWithoutDelimiter -> Bool)
    -> Eq PatternWithoutDelimiter
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PatternWithoutDelimiter -> PatternWithoutDelimiter -> Bool
    == :: PatternWithoutDelimiter -> PatternWithoutDelimiter -> Bool
    $c/= :: PatternWithoutDelimiter -> PatternWithoutDelimiter -> Bool
    /= :: PatternWithoutDelimiter -> PatternWithoutDelimiter -> Bool
    P.Eq, Int -> PatternWithoutDelimiter -> ShowS
    [PatternWithoutDelimiter] -> ShowS
    PatternWithoutDelimiter -> [Char]
    (Int -> PatternWithoutDelimiter -> ShowS)
    -> (PatternWithoutDelimiter -> [Char])
    -> ([PatternWithoutDelimiter] -> ShowS)
    -> Show PatternWithoutDelimiter
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PatternWithoutDelimiter -> ShowS
    showsPrec :: Int -> PatternWithoutDelimiter -> ShowS
    $cshow :: PatternWithoutDelimiter -> [Char]
    show :: PatternWithoutDelimiter -> [Char]
    $cshowList :: [PatternWithoutDelimiter] -> ShowS
    showList :: [PatternWithoutDelimiter] -> ShowS
    P.Show)

    -- ** PetId
    newtype PetId = PetId { PetId -> Integer
    unPetId :: Integer } deriving (PetId -> PetId -> Bool
    (PetId -> PetId -> Bool) -> (PetId -> PetId -> Bool) -> Eq PetId
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PetId -> PetId -> Bool
    == :: PetId -> PetId -> Bool
    $c/= :: PetId -> PetId -> Bool
    /= :: PetId -> PetId -> Bool
    P.Eq, Int -> PetId -> ShowS
    [PetId] -> ShowS
    PetId -> [Char]
    (Int -> PetId -> ShowS)
    -> (PetId -> [Char]) -> ([PetId] -> ShowS) -> Show PetId
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PetId -> ShowS
    showsPrec :: Int -> PetId -> ShowS
    $cshow :: PetId -> [Char]
    show :: PetId -> [Char]
    $cshowList :: [PetId] -> ShowS
    showList :: [PetId] -> ShowS
    P.Show)

    -- ** Pipe
    newtype Pipe = Pipe { Pipe -> [Text]
    unPipe :: [Text] } deriving (Pipe -> Pipe -> Bool
    (Pipe -> Pipe -> Bool) -> (Pipe -> Pipe -> Bool) -> Eq Pipe
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Pipe -> Pipe -> Bool
    == :: Pipe -> Pipe -> Bool
    $c/= :: Pipe -> Pipe -> Bool
    /= :: Pipe -> Pipe -> Bool
    P.Eq, Int -> Pipe -> ShowS
    [Pipe] -> ShowS
    Pipe -> [Char]
    (Int -> Pipe -> ShowS)
    -> (Pipe -> [Char]) -> ([Pipe] -> ShowS) -> Show Pipe
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Pipe -> ShowS
    showsPrec :: Int -> Pipe -> ShowS
    $cshow :: Pipe -> [Char]
    show :: Pipe -> [Char]
    $cshowList :: [Pipe] -> ShowS
    showList :: [Pipe] -> ShowS
    P.Show)

    -- ** Query
    newtype Query = Query { Query -> Text
    unQuery :: Text } deriving (Query -> Query -> Bool
    (Query -> Query -> Bool) -> (Query -> Query -> Bool) -> Eq Query
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Query -> Query -> Bool
    == :: Query -> Query -> Bool
    $c/= :: Query -> Query -> Bool
    /= :: Query -> Query -> Bool
    P.Eq, Int -> Query -> ShowS
    [Query] -> ShowS
    Query -> [Char]
    (Int -> Query -> ShowS)
    -> (Query -> [Char]) -> ([Query] -> ShowS) -> Show Query
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Query -> ShowS
    showsPrec :: Int -> Query -> ShowS
    $cshow :: Query -> [Char]
    show :: Query -> [Char]
    $cshowList :: [Query] -> ShowS
    showList :: [Query] -> ShowS
    P.Show)

    -- ** RequiredBooleanGroup
    newtype RequiredBooleanGroup = RequiredBooleanGroup { RequiredBooleanGroup -> Bool
    unRequiredBooleanGroup :: Bool } deriving (RequiredBooleanGroup -> RequiredBooleanGroup -> Bool
    (RequiredBooleanGroup -> RequiredBooleanGroup -> Bool)
    -> (RequiredBooleanGroup -> RequiredBooleanGroup -> Bool)
    -> Eq RequiredBooleanGroup
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RequiredBooleanGroup -> RequiredBooleanGroup -> Bool
    == :: RequiredBooleanGroup -> RequiredBooleanGroup -> Bool
    $c/= :: RequiredBooleanGroup -> RequiredBooleanGroup -> Bool
    /= :: RequiredBooleanGroup -> RequiredBooleanGroup -> Bool
    P.Eq, Int -> RequiredBooleanGroup -> ShowS
    [RequiredBooleanGroup] -> ShowS
    RequiredBooleanGroup -> [Char]
    (Int -> RequiredBooleanGroup -> ShowS)
    -> (RequiredBooleanGroup -> [Char])
    -> ([RequiredBooleanGroup] -> ShowS)
    -> Show RequiredBooleanGroup
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RequiredBooleanGroup -> ShowS
    showsPrec :: Int -> RequiredBooleanGroup -> ShowS
    $cshow :: RequiredBooleanGroup -> [Char]
    show :: RequiredBooleanGroup -> [Char]
    $cshowList :: [RequiredBooleanGroup] -> ShowS
    showList :: [RequiredBooleanGroup] -> ShowS
    P.Show)

    -- ** RequiredFile
    newtype RequiredFile = RequiredFile { RequiredFile -> [Char]
    unRequiredFile :: FilePath } deriving (RequiredFile -> RequiredFile -> Bool
    (RequiredFile -> RequiredFile -> Bool)
    -> (RequiredFile -> RequiredFile -> Bool) -> Eq RequiredFile
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RequiredFile -> RequiredFile -> Bool
    == :: RequiredFile -> RequiredFile -> Bool
    $c/= :: RequiredFile -> RequiredFile -> Bool
    /= :: RequiredFile -> RequiredFile -> Bool
    P.Eq, Int -> RequiredFile -> ShowS
    [RequiredFile] -> ShowS
    RequiredFile -> [Char]
    (Int -> RequiredFile -> ShowS)
    -> (RequiredFile -> [Char])
    -> ([RequiredFile] -> ShowS)
    -> Show RequiredFile
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RequiredFile -> ShowS
    showsPrec :: Int -> RequiredFile -> ShowS
    $cshow :: RequiredFile -> [Char]
    show :: RequiredFile -> [Char]
    $cshowList :: [RequiredFile] -> ShowS
    showList :: [RequiredFile] -> ShowS
    P.Show)

    -- ** RequiredInt64Group
    newtype RequiredInt64Group = RequiredInt64Group { RequiredInt64Group -> Integer
    unRequiredInt64Group :: Integer } deriving (RequiredInt64Group -> RequiredInt64Group -> Bool
    (RequiredInt64Group -> RequiredInt64Group -> Bool)
    -> (RequiredInt64Group -> RequiredInt64Group -> Bool)
    -> Eq RequiredInt64Group
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RequiredInt64Group -> RequiredInt64Group -> Bool
    == :: RequiredInt64Group -> RequiredInt64Group -> Bool
    $c/= :: RequiredInt64Group -> RequiredInt64Group -> Bool
    /= :: RequiredInt64Group -> RequiredInt64Group -> Bool
    P.Eq, Int -> RequiredInt64Group -> ShowS
    [RequiredInt64Group] -> ShowS
    RequiredInt64Group -> [Char]
    (Int -> RequiredInt64Group -> ShowS)
    -> (RequiredInt64Group -> [Char])
    -> ([RequiredInt64Group] -> ShowS)
    -> Show RequiredInt64Group
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RequiredInt64Group -> ShowS
    showsPrec :: Int -> RequiredInt64Group -> ShowS
    $cshow :: RequiredInt64Group -> [Char]
    show :: RequiredInt64Group -> [Char]
    $cshowList :: [RequiredInt64Group] -> ShowS
    showList :: [RequiredInt64Group] -> ShowS
    P.Show)

    -- ** RequiredStringGroup
    newtype RequiredStringGroup = RequiredStringGroup { RequiredStringGroup -> Int
    unRequiredStringGroup :: Int } deriving (RequiredStringGroup -> RequiredStringGroup -> Bool
    (RequiredStringGroup -> RequiredStringGroup -> Bool)
    -> (RequiredStringGroup -> RequiredStringGroup -> Bool)
    -> Eq RequiredStringGroup
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RequiredStringGroup -> RequiredStringGroup -> Bool
    == :: RequiredStringGroup -> RequiredStringGroup -> Bool
    $c/= :: RequiredStringGroup -> RequiredStringGroup -> Bool
    /= :: RequiredStringGroup -> RequiredStringGroup -> Bool
    P.Eq, Int -> RequiredStringGroup -> ShowS
    [RequiredStringGroup] -> ShowS
    RequiredStringGroup -> [Char]
    (Int -> RequiredStringGroup -> ShowS)
    -> (RequiredStringGroup -> [Char])
    -> ([RequiredStringGroup] -> ShowS)
    -> Show RequiredStringGroup
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RequiredStringGroup -> ShowS
    showsPrec :: Int -> RequiredStringGroup -> ShowS
    $cshow :: RequiredStringGroup -> [Char]
    show :: RequiredStringGroup -> [Char]
    $cshowList :: [RequiredStringGroup] -> ShowS
    showList :: [RequiredStringGroup] -> ShowS
    P.Show)

    -- ** Status
    newtype Status = Status { Status -> [E'Status2]
    unStatus :: [E'Status2] } deriving (Status -> Status -> Bool
    (Status -> Status -> Bool)
    -> (Status -> Status -> Bool) -> Eq Status
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Status -> Status -> Bool
    == :: Status -> Status -> Bool
    $c/= :: Status -> Status -> Bool
    /= :: Status -> Status -> Bool
    P.Eq, Int -> Status -> ShowS
    [Status] -> ShowS
    Status -> [Char]
    (Int -> Status -> ShowS)
    -> (Status -> [Char]) -> ([Status] -> ShowS) -> Show Status
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Status -> ShowS
    showsPrec :: Int -> Status -> ShowS
    $cshow :: Status -> [Char]
    show :: Status -> [Char]
    $cshowList :: [Status] -> ShowS
    showList :: [Status] -> ShowS
    P.Show)

    -- ** StatusText
    newtype StatusText = StatusText { StatusText -> Text
    unStatusText :: Text } deriving (StatusText -> StatusText -> Bool
    (StatusText -> StatusText -> Bool)
    -> (StatusText -> StatusText -> Bool) -> Eq StatusText
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StatusText -> StatusText -> Bool
    == :: StatusText -> StatusText -> Bool
    $c/= :: StatusText -> StatusText -> Bool
    /= :: StatusText -> StatusText -> Bool
    P.Eq, Int -> StatusText -> ShowS
    [StatusText] -> ShowS
    StatusText -> [Char]
    (Int -> StatusText -> ShowS)
    -> (StatusText -> [Char])
    -> ([StatusText] -> ShowS)
    -> Show StatusText
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> StatusText -> ShowS
    showsPrec :: Int -> StatusText -> ShowS
    $cshow :: StatusText -> [Char]
    show :: StatusText -> [Char]
    $cshowList :: [StatusText] -> ShowS
    showList :: [StatusText] -> ShowS
    P.Show)

    -- ** StringGroup
    newtype StringGroup = StringGroup { StringGroup -> Int
    unStringGroup :: Int } deriving (StringGroup -> StringGroup -> Bool
    (StringGroup -> StringGroup -> Bool)
    -> (StringGroup -> StringGroup -> Bool) -> Eq StringGroup
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StringGroup -> StringGroup -> Bool
    == :: StringGroup -> StringGroup -> Bool
    $c/= :: StringGroup -> StringGroup -> Bool
    /= :: StringGroup -> StringGroup -> Bool
    P.Eq, Int -> StringGroup -> ShowS
    [StringGroup] -> ShowS
    StringGroup -> [Char]
    (Int -> StringGroup -> ShowS)
    -> (StringGroup -> [Char])
    -> ([StringGroup] -> ShowS)
    -> Show StringGroup
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> StringGroup -> ShowS
    showsPrec :: Int -> StringGroup -> ShowS
    $cshow :: StringGroup -> [Char]
    show :: StringGroup -> [Char]
    $cshowList :: [StringGroup] -> ShowS
    showList :: [StringGroup] -> ShowS
    P.Show)

    -- ** Tags
    newtype Tags = Tags { Tags -> [Text]
    unTags :: [Text] } deriving (Tags -> Tags -> Bool
    (Tags -> Tags -> Bool) -> (Tags -> Tags -> Bool) -> Eq Tags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Tags -> Tags -> Bool
    == :: Tags -> Tags -> Bool
    $c/= :: Tags -> Tags -> Bool
    /= :: Tags -> Tags -> Bool
    P.Eq, Int -> Tags -> ShowS
    [Tags] -> ShowS
    Tags -> [Char]
    (Int -> Tags -> ShowS)
    -> (Tags -> [Char]) -> ([Tags] -> ShowS) -> Show Tags
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Tags -> ShowS
    showsPrec :: Int -> Tags -> ShowS
    $cshow :: Tags -> [Char]
    show :: Tags -> [Char]
    $cshowList :: [Tags] -> ShowS
    showList :: [Tags] -> ShowS
    P.Show)

    -- ** Url
    newtype Url = Url { Url -> [Text]
    unUrl :: [Text] } deriving (Url -> Url -> Bool
    (Url -> Url -> Bool) -> (Url -> Url -> Bool) -> Eq Url
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Url -> Url -> Bool
    == :: Url -> Url -> Bool
    $c/= :: Url -> Url -> Bool
    /= :: Url -> Url -> Bool
    P.Eq, Int -> Url -> ShowS
    [Url] -> ShowS
    Url -> [Char]
    (Int -> Url -> ShowS)
    -> (Url -> [Char]) -> ([Url] -> ShowS) -> Show Url
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Url -> ShowS
    showsPrec :: Int -> Url -> ShowS
    $cshow :: Url -> [Char]
    show :: Url -> [Char]
    $cshowList :: [Url] -> ShowS
    showList :: [Url] -> ShowS
    P.Show)

    -- ** Username
    newtype Username = Username { Username -> Text
    unUsername :: Text } deriving (Username -> Username -> Bool
    (Username -> Username -> Bool)
    -> (Username -> Username -> Bool) -> Eq Username
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Username -> Username -> Bool
    == :: Username -> Username -> Bool
    $c/= :: Username -> Username -> Bool
    /= :: Username -> Username -> Bool
    P.Eq, Int -> Username -> ShowS
    [Username] -> ShowS
    Username -> [Char]
    (Int -> Username -> ShowS)
    -> (Username -> [Char]) -> ([Username] -> ShowS) -> Show Username
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Username -> ShowS
    showsPrec :: Int -> Username -> ShowS
    $cshow :: Username -> [Char]
    show :: Username -> [Char]
    $cshowList :: [Username] -> ShowS
    showList :: [Username] -> ShowS
    P.Show)

    -- * Models

    -- ** AdditionalPropertiesAnyType
    -- | AdditionalPropertiesAnyType
    data AdditionalPropertiesAnyType = AdditionalPropertiesAnyType
      { AdditionalPropertiesAnyType -> Maybe Text
    additionalPropertiesAnyTypeName :: !(Maybe Text) -- ^ "name"
      } deriving (Int -> AdditionalPropertiesAnyType -> ShowS
    [AdditionalPropertiesAnyType] -> ShowS
    AdditionalPropertiesAnyType -> [Char]
    (Int -> AdditionalPropertiesAnyType -> ShowS)
    -> (AdditionalPropertiesAnyType -> [Char])
    -> ([AdditionalPropertiesAnyType] -> ShowS)
    -> Show AdditionalPropertiesAnyType
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditionalPropertiesAnyType -> ShowS
    showsPrec :: Int -> AdditionalPropertiesAnyType -> ShowS
    $cshow :: AdditionalPropertiesAnyType -> [Char]
    show :: AdditionalPropertiesAnyType -> [Char]
    $cshowList :: [AdditionalPropertiesAnyType] -> ShowS
    showList :: [AdditionalPropertiesAnyType] -> ShowS
    P.Show, AdditionalPropertiesAnyType -> AdditionalPropertiesAnyType -> Bool
    (AdditionalPropertiesAnyType
     -> AdditionalPropertiesAnyType -> Bool)
    -> (AdditionalPropertiesAnyType
        -> AdditionalPropertiesAnyType -> Bool)
    -> Eq AdditionalPropertiesAnyType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditionalPropertiesAnyType -> AdditionalPropertiesAnyType -> Bool
    == :: AdditionalPropertiesAnyType -> AdditionalPropertiesAnyType -> Bool
    $c/= :: AdditionalPropertiesAnyType -> AdditionalPropertiesAnyType -> Bool
    /= :: AdditionalPropertiesAnyType -> AdditionalPropertiesAnyType -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON AdditionalPropertiesAnyType
    instance A.FromJSON AdditionalPropertiesAnyType where
      parseJSON :: Value -> Parser AdditionalPropertiesAnyType
    parseJSON = [Char]
    -> (Object -> Parser AdditionalPropertiesAnyType)
    -> Value
    -> Parser AdditionalPropertiesAnyType
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "AdditionalPropertiesAnyType" ((Object -> Parser AdditionalPropertiesAnyType)
     -> Value -> Parser AdditionalPropertiesAnyType)
    -> (Object -> Parser AdditionalPropertiesAnyType)
    -> Value
    -> Parser AdditionalPropertiesAnyType
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> AdditionalPropertiesAnyType
    AdditionalPropertiesAnyType
          (Maybe Text -> AdditionalPropertiesAnyType)
    -> Parser (Maybe Text) -> Parser AdditionalPropertiesAnyType
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name")

    -- | ToJSON AdditionalPropertiesAnyType
    instance A.ToJSON AdditionalPropertiesAnyType where
      toJSON :: AdditionalPropertiesAnyType -> Value
    toJSON AdditionalPropertiesAnyType {Maybe Text
    additionalPropertiesAnyTypeName :: AdditionalPropertiesAnyType -> Maybe Text
    additionalPropertiesAnyTypeName :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "name" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    additionalPropertiesAnyTypeName
          ]

    -- | Construct a value of type 'AdditionalPropertiesAnyType' (by applying it's required fields, if any)
    mkAdditionalPropertiesAnyType
      :: AdditionalPropertiesAnyType
    mkAdditionalPropertiesAnyType :: AdditionalPropertiesAnyType
    mkAdditionalPropertiesAnyType =
      AdditionalPropertiesAnyType
      { additionalPropertiesAnyTypeName :: Maybe Text
    additionalPropertiesAnyTypeName = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** AdditionalPropertiesArray
    -- | AdditionalPropertiesArray
    data AdditionalPropertiesArray = AdditionalPropertiesArray
      { AdditionalPropertiesArray -> Maybe Text
    additionalPropertiesArrayName :: !(Maybe Text) -- ^ "name"
      } deriving (Int -> AdditionalPropertiesArray -> ShowS
    [AdditionalPropertiesArray] -> ShowS
    AdditionalPropertiesArray -> [Char]
    (Int -> AdditionalPropertiesArray -> ShowS)
    -> (AdditionalPropertiesArray -> [Char])
    -> ([AdditionalPropertiesArray] -> ShowS)
    -> Show AdditionalPropertiesArray
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditionalPropertiesArray -> ShowS
    showsPrec :: Int -> AdditionalPropertiesArray -> ShowS
    $cshow :: AdditionalPropertiesArray -> [Char]
    show :: AdditionalPropertiesArray -> [Char]
    $cshowList :: [AdditionalPropertiesArray] -> ShowS
    showList :: [AdditionalPropertiesArray] -> ShowS
    P.Show, AdditionalPropertiesArray -> AdditionalPropertiesArray -> Bool
    (AdditionalPropertiesArray -> AdditionalPropertiesArray -> Bool)
    -> (AdditionalPropertiesArray -> AdditionalPropertiesArray -> Bool)
    -> Eq AdditionalPropertiesArray
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditionalPropertiesArray -> AdditionalPropertiesArray -> Bool
    == :: AdditionalPropertiesArray -> AdditionalPropertiesArray -> Bool
    $c/= :: AdditionalPropertiesArray -> AdditionalPropertiesArray -> Bool
    /= :: AdditionalPropertiesArray -> AdditionalPropertiesArray -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON AdditionalPropertiesArray
    instance A.FromJSON AdditionalPropertiesArray where
      parseJSON :: Value -> Parser AdditionalPropertiesArray
    parseJSON = [Char]
    -> (Object -> Parser AdditionalPropertiesArray)
    -> Value
    -> Parser AdditionalPropertiesArray
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "AdditionalPropertiesArray" ((Object -> Parser AdditionalPropertiesArray)
     -> Value -> Parser AdditionalPropertiesArray)
    -> (Object -> Parser AdditionalPropertiesArray)
    -> Value
    -> Parser AdditionalPropertiesArray
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> AdditionalPropertiesArray
    AdditionalPropertiesArray
          (Maybe Text -> AdditionalPropertiesArray)
    -> Parser (Maybe Text) -> Parser AdditionalPropertiesArray
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name")

    -- | ToJSON AdditionalPropertiesArray
    instance A.ToJSON AdditionalPropertiesArray where
      toJSON :: AdditionalPropertiesArray -> Value
    toJSON AdditionalPropertiesArray {Maybe Text
    additionalPropertiesArrayName :: AdditionalPropertiesArray -> Maybe Text
    additionalPropertiesArrayName :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "name" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    additionalPropertiesArrayName
          ]

    -- | Construct a value of type 'AdditionalPropertiesArray' (by applying it's required fields, if any)
    mkAdditionalPropertiesArray
      :: AdditionalPropertiesArray
    mkAdditionalPropertiesArray :: AdditionalPropertiesArray
    mkAdditionalPropertiesArray =
      AdditionalPropertiesArray
      { additionalPropertiesArrayName :: Maybe Text
    additionalPropertiesArrayName = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** AdditionalPropertiesBoolean
    -- | AdditionalPropertiesBoolean
    data AdditionalPropertiesBoolean = AdditionalPropertiesBoolean
      { AdditionalPropertiesBoolean -> Maybe Text
    additionalPropertiesBooleanName :: !(Maybe Text) -- ^ "name"
      } deriving (Int -> AdditionalPropertiesBoolean -> ShowS
    [AdditionalPropertiesBoolean] -> ShowS
    AdditionalPropertiesBoolean -> [Char]
    (Int -> AdditionalPropertiesBoolean -> ShowS)
    -> (AdditionalPropertiesBoolean -> [Char])
    -> ([AdditionalPropertiesBoolean] -> ShowS)
    -> Show AdditionalPropertiesBoolean
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditionalPropertiesBoolean -> ShowS
    showsPrec :: Int -> AdditionalPropertiesBoolean -> ShowS
    $cshow :: AdditionalPropertiesBoolean -> [Char]
    show :: AdditionalPropertiesBoolean -> [Char]
    $cshowList :: [AdditionalPropertiesBoolean] -> ShowS
    showList :: [AdditionalPropertiesBoolean] -> ShowS
    P.Show, AdditionalPropertiesBoolean -> AdditionalPropertiesBoolean -> Bool
    (AdditionalPropertiesBoolean
     -> AdditionalPropertiesBoolean -> Bool)
    -> (AdditionalPropertiesBoolean
        -> AdditionalPropertiesBoolean -> Bool)
    -> Eq AdditionalPropertiesBoolean
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditionalPropertiesBoolean -> AdditionalPropertiesBoolean -> Bool
    == :: AdditionalPropertiesBoolean -> AdditionalPropertiesBoolean -> Bool
    $c/= :: AdditionalPropertiesBoolean -> AdditionalPropertiesBoolean -> Bool
    /= :: AdditionalPropertiesBoolean -> AdditionalPropertiesBoolean -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON AdditionalPropertiesBoolean
    instance A.FromJSON AdditionalPropertiesBoolean where
      parseJSON :: Value -> Parser AdditionalPropertiesBoolean
    parseJSON = [Char]
    -> (Object -> Parser AdditionalPropertiesBoolean)
    -> Value
    -> Parser AdditionalPropertiesBoolean
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "AdditionalPropertiesBoolean" ((Object -> Parser AdditionalPropertiesBoolean)
     -> Value -> Parser AdditionalPropertiesBoolean)
    -> (Object -> Parser AdditionalPropertiesBoolean)
    -> Value
    -> Parser AdditionalPropertiesBoolean
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> AdditionalPropertiesBoolean
    AdditionalPropertiesBoolean
          (Maybe Text -> AdditionalPropertiesBoolean)
    -> Parser (Maybe Text) -> Parser AdditionalPropertiesBoolean
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name")

    -- | ToJSON AdditionalPropertiesBoolean
    instance A.ToJSON AdditionalPropertiesBoolean where
      toJSON :: AdditionalPropertiesBoolean -> Value
    toJSON AdditionalPropertiesBoolean {Maybe Text
    additionalPropertiesBooleanName :: AdditionalPropertiesBoolean -> Maybe Text
    additionalPropertiesBooleanName :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "name" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    additionalPropertiesBooleanName
          ]

    -- | Construct a value of type 'AdditionalPropertiesBoolean' (by applying it's required fields, if any)
    mkAdditionalPropertiesBoolean
      :: AdditionalPropertiesBoolean
    mkAdditionalPropertiesBoolean :: AdditionalPropertiesBoolean
    mkAdditionalPropertiesBoolean =
      AdditionalPropertiesBoolean
      { additionalPropertiesBooleanName :: Maybe Text
    additionalPropertiesBooleanName = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** AdditionalPropertiesClass
    -- | AdditionalPropertiesClass
    data AdditionalPropertiesClass = AdditionalPropertiesClass
      { AdditionalPropertiesClass -> Maybe (Map [Char] Text)
    additionalPropertiesClassMapString :: !(Maybe (Map.Map String Text)) -- ^ "map_string"
      , AdditionalPropertiesClass -> Maybe (Map [Char] Double)
    additionalPropertiesClassMapNumber :: !(Maybe (Map.Map String Double)) -- ^ "map_number"
      , AdditionalPropertiesClass -> Maybe (Map [Char] Int)
    additionalPropertiesClassMapInteger :: !(Maybe (Map.Map String Int)) -- ^ "map_integer"
      , AdditionalPropertiesClass -> Maybe (Map [Char] Bool)
    additionalPropertiesClassMapBoolean :: !(Maybe (Map.Map String Bool)) -- ^ "map_boolean"
      , AdditionalPropertiesClass -> Maybe (Map [Char] [Int])
    additionalPropertiesClassMapArrayInteger :: !(Maybe (Map.Map String [Int])) -- ^ "map_array_integer"
      , AdditionalPropertiesClass -> Maybe (Map [Char] [Value])
    additionalPropertiesClassMapArrayAnytype :: !(Maybe (Map.Map String [A.Value])) -- ^ "map_array_anytype"
      , AdditionalPropertiesClass -> Maybe (Map [Char] (Map [Char] Text))
    additionalPropertiesClassMapMapString :: !(Maybe (Map.Map String (Map.Map String Text))) -- ^ "map_map_string"
      , AdditionalPropertiesClass -> Maybe (Map [Char] (Map [Char] Value))
    additionalPropertiesClassMapMapAnytype :: !(Maybe (Map.Map String (Map.Map String A.Value))) -- ^ "map_map_anytype"
      , AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype1 :: !(Maybe A.Value) -- ^ "anytype_1"
      , AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: !(Maybe A.Value) -- ^ "anytype_2"
      , AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: !(Maybe A.Value) -- ^ "anytype_3"
      } deriving (Int -> AdditionalPropertiesClass -> ShowS
    [AdditionalPropertiesClass] -> ShowS
    AdditionalPropertiesClass -> [Char]
    (Int -> AdditionalPropertiesClass -> ShowS)
    -> (AdditionalPropertiesClass -> [Char])
    -> ([AdditionalPropertiesClass] -> ShowS)
    -> Show AdditionalPropertiesClass
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditionalPropertiesClass -> ShowS
    showsPrec :: Int -> AdditionalPropertiesClass -> ShowS
    $cshow :: AdditionalPropertiesClass -> [Char]
    show :: AdditionalPropertiesClass -> [Char]
    $cshowList :: [AdditionalPropertiesClass] -> ShowS
    showList :: [AdditionalPropertiesClass] -> ShowS
    P.Show, AdditionalPropertiesClass -> AdditionalPropertiesClass -> Bool
    (AdditionalPropertiesClass -> AdditionalPropertiesClass -> Bool)
    -> (AdditionalPropertiesClass -> AdditionalPropertiesClass -> Bool)
    -> Eq AdditionalPropertiesClass
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditionalPropertiesClass -> AdditionalPropertiesClass -> Bool
    == :: AdditionalPropertiesClass -> AdditionalPropertiesClass -> Bool
    $c/= :: AdditionalPropertiesClass -> AdditionalPropertiesClass -> Bool
    /= :: AdditionalPropertiesClass -> AdditionalPropertiesClass -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON AdditionalPropertiesClass
    instance A.FromJSON AdditionalPropertiesClass where
      parseJSON :: Value -> Parser AdditionalPropertiesClass
    parseJSON = [Char]
    -> (Object -> Parser AdditionalPropertiesClass)
    -> Value
    -> Parser AdditionalPropertiesClass
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "AdditionalPropertiesClass" ((Object -> Parser AdditionalPropertiesClass)
     -> Value -> Parser AdditionalPropertiesClass)
    -> (Object -> Parser AdditionalPropertiesClass)
    -> Value
    -> Parser AdditionalPropertiesClass
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe (Map [Char] Text)
    -> Maybe (Map [Char] Double)
    -> Maybe (Map [Char] Int)
    -> Maybe (Map [Char] Bool)
    -> Maybe (Map [Char] [Int])
    -> Maybe (Map [Char] [Value])
    -> Maybe (Map [Char] (Map [Char] Text))
    -> Maybe (Map [Char] (Map [Char] Value))
    -> Maybe Value
    -> Maybe Value
    -> Maybe Value
    -> AdditionalPropertiesClass
    AdditionalPropertiesClass
          (Maybe (Map [Char] Text)
     -> Maybe (Map [Char] Double)
     -> Maybe (Map [Char] Int)
     -> Maybe (Map [Char] Bool)
     -> Maybe (Map [Char] [Int])
     -> Maybe (Map [Char] [Value])
     -> Maybe (Map [Char] (Map [Char] Text))
     -> Maybe (Map [Char] (Map [Char] Value))
     -> Maybe Value
     -> Maybe Value
     -> Maybe Value
     -> AdditionalPropertiesClass)
    -> Parser (Maybe (Map [Char] Text))
    -> Parser
         (Maybe (Map [Char] Double)
          -> Maybe (Map [Char] Int)
          -> Maybe (Map [Char] Bool)
          -> Maybe (Map [Char] [Int])
          -> Maybe (Map [Char] [Value])
          -> Maybe (Map [Char] (Map [Char] Text))
          -> Maybe (Map [Char] (Map [Char] Value))
          -> Maybe Value
          -> Maybe Value
          -> Maybe Value
          -> AdditionalPropertiesClass)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] Text))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_string")
          Parser
      (Maybe (Map [Char] Double)
       -> Maybe (Map [Char] Int)
       -> Maybe (Map [Char] Bool)
       -> Maybe (Map [Char] [Int])
       -> Maybe (Map [Char] [Value])
       -> Maybe (Map [Char] (Map [Char] Text))
       -> Maybe (Map [Char] (Map [Char] Value))
       -> Maybe Value
       -> Maybe Value
       -> Maybe Value
       -> AdditionalPropertiesClass)
    -> Parser (Maybe (Map [Char] Double))
    -> Parser
         (Maybe (Map [Char] Int)
          -> Maybe (Map [Char] Bool)
          -> Maybe (Map [Char] [Int])
          -> Maybe (Map [Char] [Value])
          -> Maybe (Map [Char] (Map [Char] Text))
          -> Maybe (Map [Char] (Map [Char] Value))
          -> Maybe Value
          -> Maybe Value
          -> Maybe Value
          -> AdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] Double))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_number")
          Parser
      (Maybe (Map [Char] Int)
       -> Maybe (Map [Char] Bool)
       -> Maybe (Map [Char] [Int])
       -> Maybe (Map [Char] [Value])
       -> Maybe (Map [Char] (Map [Char] Text))
       -> Maybe (Map [Char] (Map [Char] Value))
       -> Maybe Value
       -> Maybe Value
       -> Maybe Value
       -> AdditionalPropertiesClass)
    -> Parser (Maybe (Map [Char] Int))
    -> Parser
         (Maybe (Map [Char] Bool)
          -> Maybe (Map [Char] [Int])
          -> Maybe (Map [Char] [Value])
          -> Maybe (Map [Char] (Map [Char] Text))
          -> Maybe (Map [Char] (Map [Char] Value))
          -> Maybe Value
          -> Maybe Value
          -> Maybe Value
          -> AdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] Int))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_integer")
          Parser
      (Maybe (Map [Char] Bool)
       -> Maybe (Map [Char] [Int])
       -> Maybe (Map [Char] [Value])
       -> Maybe (Map [Char] (Map [Char] Text))
       -> Maybe (Map [Char] (Map [Char] Value))
       -> Maybe Value
       -> Maybe Value
       -> Maybe Value
       -> AdditionalPropertiesClass)
    -> Parser (Maybe (Map [Char] Bool))
    -> Parser
         (Maybe (Map [Char] [Int])
          -> Maybe (Map [Char] [Value])
          -> Maybe (Map [Char] (Map [Char] Text))
          -> Maybe (Map [Char] (Map [Char] Value))
          -> Maybe Value
          -> Maybe Value
          -> Maybe Value
          -> AdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] Bool))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_boolean")
          Parser
      (Maybe (Map [Char] [Int])
       -> Maybe (Map [Char] [Value])
       -> Maybe (Map [Char] (Map [Char] Text))
       -> Maybe (Map [Char] (Map [Char] Value))
       -> Maybe Value
       -> Maybe Value
       -> Maybe Value
       -> AdditionalPropertiesClass)
    -> Parser (Maybe (Map [Char] [Int]))
    -> Parser
         (Maybe (Map [Char] [Value])
          -> Maybe (Map [Char] (Map [Char] Text))
          -> Maybe (Map [Char] (Map [Char] Value))
          -> Maybe Value
          -> Maybe Value
          -> Maybe Value
          -> AdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] [Int]))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_array_integer")
          Parser
      (Maybe (Map [Char] [Value])
       -> Maybe (Map [Char] (Map [Char] Text))
       -> Maybe (Map [Char] (Map [Char] Value))
       -> Maybe Value
       -> Maybe Value
       -> Maybe Value
       -> AdditionalPropertiesClass)
    -> Parser (Maybe (Map [Char] [Value]))
    -> Parser
         (Maybe (Map [Char] (Map [Char] Text))
          -> Maybe (Map [Char] (Map [Char] Value))
          -> Maybe Value
          -> Maybe Value
          -> Maybe Value
          -> AdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] [Value]))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_array_anytype")
          Parser
      (Maybe (Map [Char] (Map [Char] Text))
       -> Maybe (Map [Char] (Map [Char] Value))
       -> Maybe Value
       -> Maybe Value
       -> Maybe Value
       -> AdditionalPropertiesClass)
    -> Parser (Maybe (Map [Char] (Map [Char] Text)))
    -> Parser
         (Maybe (Map [Char] (Map [Char] Value))
          -> Maybe Value
          -> Maybe Value
          -> Maybe Value
          -> AdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] (Map [Char] Text)))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_map_string")
          Parser
      (Maybe (Map [Char] (Map [Char] Value))
       -> Maybe Value
       -> Maybe Value
       -> Maybe Value
       -> AdditionalPropertiesClass)
    -> Parser (Maybe (Map [Char] (Map [Char] Value)))
    -> Parser
         (Maybe Value
          -> Maybe Value -> Maybe Value -> AdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] (Map [Char] Value)))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_map_anytype")
          Parser
      (Maybe Value
       -> Maybe Value -> Maybe Value -> AdditionalPropertiesClass)
    -> Parser (Maybe Value)
    -> Parser (Maybe Value -> Maybe Value -> AdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Value)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "anytype_1")
          Parser (Maybe Value -> Maybe Value -> AdditionalPropertiesClass)
    -> Parser (Maybe Value)
    -> Parser (Maybe Value -> AdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Value)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "anytype_2")
          Parser (Maybe Value -> AdditionalPropertiesClass)
    -> Parser (Maybe Value) -> Parser AdditionalPropertiesClass
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Value)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "anytype_3")

    -- | ToJSON AdditionalPropertiesClass
    instance A.ToJSON AdditionalPropertiesClass where
      toJSON :: AdditionalPropertiesClass -> Value
    toJSON AdditionalPropertiesClass {Maybe (Map [Char] Bool)
    Maybe (Map [Char] Double)
    Maybe (Map [Char] Int)
    Maybe (Map [Char] [Int])
    Maybe (Map [Char] [Value])
    Maybe (Map [Char] (Map [Char] Text))
    Maybe (Map [Char] (Map [Char] Value))
    Maybe (Map [Char] Text)
    Maybe Value
    additionalPropertiesClassMapString :: AdditionalPropertiesClass -> Maybe (Map [Char] Text)
    additionalPropertiesClassMapNumber :: AdditionalPropertiesClass -> Maybe (Map [Char] Double)
    additionalPropertiesClassMapInteger :: AdditionalPropertiesClass -> Maybe (Map [Char] Int)
    additionalPropertiesClassMapBoolean :: AdditionalPropertiesClass -> Maybe (Map [Char] Bool)
    additionalPropertiesClassMapArrayInteger :: AdditionalPropertiesClass -> Maybe (Map [Char] [Int])
    additionalPropertiesClassMapArrayAnytype :: AdditionalPropertiesClass -> Maybe (Map [Char] [Value])
    additionalPropertiesClassMapMapString :: AdditionalPropertiesClass -> Maybe (Map [Char] (Map [Char] Text))
    additionalPropertiesClassMapMapAnytype :: AdditionalPropertiesClass -> Maybe (Map [Char] (Map [Char] Value))
    additionalPropertiesClassAnytype1 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype2 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassAnytype3 :: AdditionalPropertiesClass -> Maybe Value
    additionalPropertiesClassMapString :: Maybe (Map [Char] Text)
    additionalPropertiesClassMapNumber :: Maybe (Map [Char] Double)
    additionalPropertiesClassMapInteger :: Maybe (Map [Char] Int)
    additionalPropertiesClassMapBoolean :: Maybe (Map [Char] Bool)
    additionalPropertiesClassMapArrayInteger :: Maybe (Map [Char] [Int])
    additionalPropertiesClassMapArrayAnytype :: Maybe (Map [Char] [Value])
    additionalPropertiesClassMapMapString :: Maybe (Map [Char] (Map [Char] Text))
    additionalPropertiesClassMapMapAnytype :: Maybe (Map [Char] (Map [Char] Value))
    additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype3 :: Maybe Value
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "map_string" Key -> Maybe (Map [Char] Text) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] Text)
    additionalPropertiesClassMapString
          , Key
    "map_number" Key -> Maybe (Map [Char] Double) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] Double)
    additionalPropertiesClassMapNumber
          , Key
    "map_integer" Key -> Maybe (Map [Char] Int) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] Int)
    additionalPropertiesClassMapInteger
          , Key
    "map_boolean" Key -> Maybe (Map [Char] Bool) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] Bool)
    additionalPropertiesClassMapBoolean
          , Key
    "map_array_integer" Key -> Maybe (Map [Char] [Int]) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] [Int])
    additionalPropertiesClassMapArrayInteger
          , Key
    "map_array_anytype" Key -> Maybe (Map [Char] [Value]) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] [Value])
    additionalPropertiesClassMapArrayAnytype
          , Key
    "map_map_string" Key -> Maybe (Map [Char] (Map [Char] Text)) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] (Map [Char] Text))
    additionalPropertiesClassMapMapString
          , Key
    "map_map_anytype" Key -> Maybe (Map [Char] (Map [Char] Value)) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] (Map [Char] Value))
    additionalPropertiesClassMapMapAnytype
          , Key
    "anytype_1" Key -> Maybe Value -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Value
    additionalPropertiesClassAnytype1
          , Key
    "anytype_2" Key -> Maybe Value -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Value
    additionalPropertiesClassAnytype2
          , Key
    "anytype_3" Key -> Maybe Value -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Value
    additionalPropertiesClassAnytype3
          ]

    -- | Construct a value of type 'AdditionalPropertiesClass' (by applying it's required fields, if any)
    mkAdditionalPropertiesClass
      :: AdditionalPropertiesClass
    mkAdditionalPropertiesClass :: AdditionalPropertiesClass
    mkAdditionalPropertiesClass =
      AdditionalPropertiesClass
      { additionalPropertiesClassMapString :: Maybe (Map [Char] Text)
    additionalPropertiesClassMapString = Maybe (Map [Char] Text)
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassMapNumber :: Maybe (Map [Char] Double)
    additionalPropertiesClassMapNumber = Maybe (Map [Char] Double)
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassMapInteger :: Maybe (Map [Char] Int)
    additionalPropertiesClassMapInteger = Maybe (Map [Char] Int)
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassMapBoolean :: Maybe (Map [Char] Bool)
    additionalPropertiesClassMapBoolean = Maybe (Map [Char] Bool)
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassMapArrayInteger :: Maybe (Map [Char] [Int])
    additionalPropertiesClassMapArrayInteger = Maybe (Map [Char] [Int])
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassMapArrayAnytype :: Maybe (Map [Char] [Value])
    additionalPropertiesClassMapArrayAnytype = Maybe (Map [Char] [Value])
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassMapMapString :: Maybe (Map [Char] (Map [Char] Text))
    additionalPropertiesClassMapMapString = Maybe (Map [Char] (Map [Char] Text))
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassMapMapAnytype :: Maybe (Map [Char] (Map [Char] Value))
    additionalPropertiesClassMapMapAnytype = Maybe (Map [Char] (Map [Char] Value))
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassAnytype1 :: Maybe Value
    additionalPropertiesClassAnytype1 = Maybe Value
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassAnytype2 :: Maybe Value
    additionalPropertiesClassAnytype2 = Maybe Value
    forall a. Maybe a
    Nothing
      , additionalPropertiesClassAnytype3 :: Maybe Value
    additionalPropertiesClassAnytype3 = Maybe Value
    forall a. Maybe a
    Nothing
      }

    -- ** AdditionalPropertiesInteger
    -- | AdditionalPropertiesInteger
    data AdditionalPropertiesInteger = AdditionalPropertiesInteger
      { AdditionalPropertiesInteger -> Maybe Text
    additionalPropertiesIntegerName :: !(Maybe Text) -- ^ "name"
      } deriving (Int -> AdditionalPropertiesInteger -> ShowS
    [AdditionalPropertiesInteger] -> ShowS
    AdditionalPropertiesInteger -> [Char]
    (Int -> AdditionalPropertiesInteger -> ShowS)
    -> (AdditionalPropertiesInteger -> [Char])
    -> ([AdditionalPropertiesInteger] -> ShowS)
    -> Show AdditionalPropertiesInteger
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditionalPropertiesInteger -> ShowS
    showsPrec :: Int -> AdditionalPropertiesInteger -> ShowS
    $cshow :: AdditionalPropertiesInteger -> [Char]
    show :: AdditionalPropertiesInteger -> [Char]
    $cshowList :: [AdditionalPropertiesInteger] -> ShowS
    showList :: [AdditionalPropertiesInteger] -> ShowS
    P.Show, AdditionalPropertiesInteger -> AdditionalPropertiesInteger -> Bool
    (AdditionalPropertiesInteger
     -> AdditionalPropertiesInteger -> Bool)
    -> (AdditionalPropertiesInteger
        -> AdditionalPropertiesInteger -> Bool)
    -> Eq AdditionalPropertiesInteger
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditionalPropertiesInteger -> AdditionalPropertiesInteger -> Bool
    == :: AdditionalPropertiesInteger -> AdditionalPropertiesInteger -> Bool
    $c/= :: AdditionalPropertiesInteger -> AdditionalPropertiesInteger -> Bool
    /= :: AdditionalPropertiesInteger -> AdditionalPropertiesInteger -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON AdditionalPropertiesInteger
    instance A.FromJSON AdditionalPropertiesInteger where
      parseJSON :: Value -> Parser AdditionalPropertiesInteger
    parseJSON = [Char]
    -> (Object -> Parser AdditionalPropertiesInteger)
    -> Value
    -> Parser AdditionalPropertiesInteger
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "AdditionalPropertiesInteger" ((Object -> Parser AdditionalPropertiesInteger)
     -> Value -> Parser AdditionalPropertiesInteger)
    -> (Object -> Parser AdditionalPropertiesInteger)
    -> Value
    -> Parser AdditionalPropertiesInteger
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> AdditionalPropertiesInteger
    AdditionalPropertiesInteger
          (Maybe Text -> AdditionalPropertiesInteger)
    -> Parser (Maybe Text) -> Parser AdditionalPropertiesInteger
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name")

    -- | ToJSON AdditionalPropertiesInteger
    instance A.ToJSON AdditionalPropertiesInteger where
      toJSON :: AdditionalPropertiesInteger -> Value
    toJSON AdditionalPropertiesInteger {Maybe Text
    additionalPropertiesIntegerName :: AdditionalPropertiesInteger -> Maybe Text
    additionalPropertiesIntegerName :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "name" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    additionalPropertiesIntegerName
          ]

    -- | Construct a value of type 'AdditionalPropertiesInteger' (by applying it's required fields, if any)
    mkAdditionalPropertiesInteger
      :: AdditionalPropertiesInteger
    mkAdditionalPropertiesInteger :: AdditionalPropertiesInteger
    mkAdditionalPropertiesInteger =
      AdditionalPropertiesInteger
      { additionalPropertiesIntegerName :: Maybe Text
    additionalPropertiesIntegerName = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** AdditionalPropertiesNumber
    -- | AdditionalPropertiesNumber
    data AdditionalPropertiesNumber = AdditionalPropertiesNumber
      { AdditionalPropertiesNumber -> Maybe Text
    additionalPropertiesNumberName :: !(Maybe Text) -- ^ "name"
      } deriving (Int -> AdditionalPropertiesNumber -> ShowS
    [AdditionalPropertiesNumber] -> ShowS
    AdditionalPropertiesNumber -> [Char]
    (Int -> AdditionalPropertiesNumber -> ShowS)
    -> (AdditionalPropertiesNumber -> [Char])
    -> ([AdditionalPropertiesNumber] -> ShowS)
    -> Show AdditionalPropertiesNumber
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditionalPropertiesNumber -> ShowS
    showsPrec :: Int -> AdditionalPropertiesNumber -> ShowS
    $cshow :: AdditionalPropertiesNumber -> [Char]
    show :: AdditionalPropertiesNumber -> [Char]
    $cshowList :: [AdditionalPropertiesNumber] -> ShowS
    showList :: [AdditionalPropertiesNumber] -> ShowS
    P.Show, AdditionalPropertiesNumber -> AdditionalPropertiesNumber -> Bool
    (AdditionalPropertiesNumber -> AdditionalPropertiesNumber -> Bool)
    -> (AdditionalPropertiesNumber
        -> AdditionalPropertiesNumber -> Bool)
    -> Eq AdditionalPropertiesNumber
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditionalPropertiesNumber -> AdditionalPropertiesNumber -> Bool
    == :: AdditionalPropertiesNumber -> AdditionalPropertiesNumber -> Bool
    $c/= :: AdditionalPropertiesNumber -> AdditionalPropertiesNumber -> Bool
    /= :: AdditionalPropertiesNumber -> AdditionalPropertiesNumber -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON AdditionalPropertiesNumber
    instance A.FromJSON AdditionalPropertiesNumber where
      parseJSON :: Value -> Parser AdditionalPropertiesNumber
    parseJSON = [Char]
    -> (Object -> Parser AdditionalPropertiesNumber)
    -> Value
    -> Parser AdditionalPropertiesNumber
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "AdditionalPropertiesNumber" ((Object -> Parser AdditionalPropertiesNumber)
     -> Value -> Parser AdditionalPropertiesNumber)
    -> (Object -> Parser AdditionalPropertiesNumber)
    -> Value
    -> Parser AdditionalPropertiesNumber
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> AdditionalPropertiesNumber
    AdditionalPropertiesNumber
          (Maybe Text -> AdditionalPropertiesNumber)
    -> Parser (Maybe Text) -> Parser AdditionalPropertiesNumber
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name")

    -- | ToJSON AdditionalPropertiesNumber
    instance A.ToJSON AdditionalPropertiesNumber where
      toJSON :: AdditionalPropertiesNumber -> Value
    toJSON AdditionalPropertiesNumber {Maybe Text
    additionalPropertiesNumberName :: AdditionalPropertiesNumber -> Maybe Text
    additionalPropertiesNumberName :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "name" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    additionalPropertiesNumberName
          ]

    -- | Construct a value of type 'AdditionalPropertiesNumber' (by applying it's required fields, if any)
    mkAdditionalPropertiesNumber
      :: AdditionalPropertiesNumber
    mkAdditionalPropertiesNumber :: AdditionalPropertiesNumber
    mkAdditionalPropertiesNumber =
      AdditionalPropertiesNumber
      { additionalPropertiesNumberName :: Maybe Text
    additionalPropertiesNumberName = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** AdditionalPropertiesObject
    -- | AdditionalPropertiesObject
    data AdditionalPropertiesObject = AdditionalPropertiesObject
      { AdditionalPropertiesObject -> Maybe Text
    additionalPropertiesObjectName :: !(Maybe Text) -- ^ "name"
      } deriving (Int -> AdditionalPropertiesObject -> ShowS
    [AdditionalPropertiesObject] -> ShowS
    AdditionalPropertiesObject -> [Char]
    (Int -> AdditionalPropertiesObject -> ShowS)
    -> (AdditionalPropertiesObject -> [Char])
    -> ([AdditionalPropertiesObject] -> ShowS)
    -> Show AdditionalPropertiesObject
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditionalPropertiesObject -> ShowS
    showsPrec :: Int -> AdditionalPropertiesObject -> ShowS
    $cshow :: AdditionalPropertiesObject -> [Char]
    show :: AdditionalPropertiesObject -> [Char]
    $cshowList :: [AdditionalPropertiesObject] -> ShowS
    showList :: [AdditionalPropertiesObject] -> ShowS
    P.Show, AdditionalPropertiesObject -> AdditionalPropertiesObject -> Bool
    (AdditionalPropertiesObject -> AdditionalPropertiesObject -> Bool)
    -> (AdditionalPropertiesObject
        -> AdditionalPropertiesObject -> Bool)
    -> Eq AdditionalPropertiesObject
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditionalPropertiesObject -> AdditionalPropertiesObject -> Bool
    == :: AdditionalPropertiesObject -> AdditionalPropertiesObject -> Bool
    $c/= :: AdditionalPropertiesObject -> AdditionalPropertiesObject -> Bool
    /= :: AdditionalPropertiesObject -> AdditionalPropertiesObject -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON AdditionalPropertiesObject
    instance A.FromJSON AdditionalPropertiesObject where
      parseJSON :: Value -> Parser AdditionalPropertiesObject
    parseJSON = [Char]
    -> (Object -> Parser AdditionalPropertiesObject)
    -> Value
    -> Parser AdditionalPropertiesObject
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "AdditionalPropertiesObject" ((Object -> Parser AdditionalPropertiesObject)
     -> Value -> Parser AdditionalPropertiesObject)
    -> (Object -> Parser AdditionalPropertiesObject)
    -> Value
    -> Parser AdditionalPropertiesObject
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> AdditionalPropertiesObject
    AdditionalPropertiesObject
          (Maybe Text -> AdditionalPropertiesObject)
    -> Parser (Maybe Text) -> Parser AdditionalPropertiesObject
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name")

    -- | ToJSON AdditionalPropertiesObject
    instance A.ToJSON AdditionalPropertiesObject where
      toJSON :: AdditionalPropertiesObject -> Value
    toJSON AdditionalPropertiesObject {Maybe Text
    additionalPropertiesObjectName :: AdditionalPropertiesObject -> Maybe Text
    additionalPropertiesObjectName :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "name" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    additionalPropertiesObjectName
          ]

    -- | Construct a value of type 'AdditionalPropertiesObject' (by applying it's required fields, if any)
    mkAdditionalPropertiesObject
      :: AdditionalPropertiesObject
    mkAdditionalPropertiesObject :: AdditionalPropertiesObject
    mkAdditionalPropertiesObject =
      AdditionalPropertiesObject
      { additionalPropertiesObjectName :: Maybe Text
    additionalPropertiesObjectName = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** AdditionalPropertiesString
    -- | AdditionalPropertiesString
    data AdditionalPropertiesString = AdditionalPropertiesString
      { AdditionalPropertiesString -> Maybe Text
    additionalPropertiesStringName :: !(Maybe Text) -- ^ "name"
      } deriving (Int -> AdditionalPropertiesString -> ShowS
    [AdditionalPropertiesString] -> ShowS
    AdditionalPropertiesString -> [Char]
    (Int -> AdditionalPropertiesString -> ShowS)
    -> (AdditionalPropertiesString -> [Char])
    -> ([AdditionalPropertiesString] -> ShowS)
    -> Show AdditionalPropertiesString
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditionalPropertiesString -> ShowS
    showsPrec :: Int -> AdditionalPropertiesString -> ShowS
    $cshow :: AdditionalPropertiesString -> [Char]
    show :: AdditionalPropertiesString -> [Char]
    $cshowList :: [AdditionalPropertiesString] -> ShowS
    showList :: [AdditionalPropertiesString] -> ShowS
    P.Show, AdditionalPropertiesString -> AdditionalPropertiesString -> Bool
    (AdditionalPropertiesString -> AdditionalPropertiesString -> Bool)
    -> (AdditionalPropertiesString
        -> AdditionalPropertiesString -> Bool)
    -> Eq AdditionalPropertiesString
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditionalPropertiesString -> AdditionalPropertiesString -> Bool
    == :: AdditionalPropertiesString -> AdditionalPropertiesString -> Bool
    $c/= :: AdditionalPropertiesString -> AdditionalPropertiesString -> Bool
    /= :: AdditionalPropertiesString -> AdditionalPropertiesString -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON AdditionalPropertiesString
    instance A.FromJSON AdditionalPropertiesString where
      parseJSON :: Value -> Parser AdditionalPropertiesString
    parseJSON = [Char]
    -> (Object -> Parser AdditionalPropertiesString)
    -> Value
    -> Parser AdditionalPropertiesString
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "AdditionalPropertiesString" ((Object -> Parser AdditionalPropertiesString)
     -> Value -> Parser AdditionalPropertiesString)
    -> (Object -> Parser AdditionalPropertiesString)
    -> Value
    -> Parser AdditionalPropertiesString
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> AdditionalPropertiesString
    AdditionalPropertiesString
          (Maybe Text -> AdditionalPropertiesString)
    -> Parser (Maybe Text) -> Parser AdditionalPropertiesString
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name")

    -- | ToJSON AdditionalPropertiesString
    instance A.ToJSON AdditionalPropertiesString where
      toJSON :: AdditionalPropertiesString -> Value
    toJSON AdditionalPropertiesString {Maybe Text
    additionalPropertiesStringName :: AdditionalPropertiesString -> Maybe Text
    additionalPropertiesStringName :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "name" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    additionalPropertiesStringName
          ]

    -- | Construct a value of type 'AdditionalPropertiesString' (by applying it's required fields, if any)
    mkAdditionalPropertiesString
      :: AdditionalPropertiesString
    mkAdditionalPropertiesString :: AdditionalPropertiesString
    mkAdditionalPropertiesString =
      AdditionalPropertiesString
      { additionalPropertiesStringName :: Maybe Text
    additionalPropertiesStringName = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** Animal
    -- | Animal
    data Animal = Animal
      { Animal -> Text
    animalClassName :: !(Text) -- ^ /Required/ "className"
      , Animal -> Maybe Text
    animalColor :: !(Maybe Text) -- ^ "color"
      } deriving (Int -> Animal -> ShowS
    [Animal] -> ShowS
    Animal -> [Char]
    (Int -> Animal -> ShowS)
    -> (Animal -> [Char]) -> ([Animal] -> ShowS) -> Show Animal
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Animal -> ShowS
    showsPrec :: Int -> Animal -> ShowS
    $cshow :: Animal -> [Char]
    show :: Animal -> [Char]
    $cshowList :: [Animal] -> ShowS
    showList :: [Animal] -> ShowS
    P.Show, Animal -> Animal -> Bool
    (Animal -> Animal -> Bool)
    -> (Animal -> Animal -> Bool) -> Eq Animal
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Animal -> Animal -> Bool
    == :: Animal -> Animal -> Bool
    $c/= :: Animal -> Animal -> Bool
    /= :: Animal -> Animal -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Animal
    instance A.FromJSON Animal where
      parseJSON :: Value -> Parser Animal
    parseJSON = [Char] -> (Object -> Parser Animal) -> Value -> Parser Animal
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Animal" ((Object -> Parser Animal) -> Value -> Parser Animal)
    -> (Object -> Parser Animal) -> Value -> Parser Animal
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Text -> Maybe Text -> Animal
    Animal
          (Text -> Maybe Text -> Animal)
    -> Parser Text -> Parser (Maybe Text -> Animal)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser Text
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "className")
          Parser (Maybe Text -> Animal)
    -> Parser (Maybe Text) -> Parser Animal
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "color")

    -- | ToJSON Animal
    instance A.ToJSON Animal where
      toJSON :: Animal -> Value
    toJSON Animal {Maybe Text
    Text
    animalClassName :: Animal -> Text
    animalColor :: Animal -> Maybe Text
    animalClassName :: Text
    animalColor :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "className" Key -> Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Text
    animalClassName
          , Key
    "color" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    animalColor
          ]

    -- | Construct a value of type 'Animal' (by applying it's required fields, if any)
    mkAnimal
      :: Text -- ^ 'animalClassName'
      -> Animal
    mkAnimal :: Text -> Animal
    mkAnimal Text
    animalClassName =
      Animal
      { Text
    animalClassName :: Text
    animalClassName :: Text
    animalClassName
      , animalColor :: Maybe Text
    animalColor = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** ApiResponse
    -- | ApiResponse
    data ApiResponse = ApiResponse
      { ApiResponse -> Maybe Int
    apiResponseCode :: !(Maybe Int) -- ^ "code"
      , ApiResponse -> Maybe Text
    apiResponseType :: !(Maybe Text) -- ^ "type"
      , ApiResponse -> Maybe Text
    apiResponseMessage :: !(Maybe Text) -- ^ "message"
      } deriving (Int -> ApiResponse -> ShowS
    [ApiResponse] -> ShowS
    ApiResponse -> [Char]
    (Int -> ApiResponse -> ShowS)
    -> (ApiResponse -> [Char])
    -> ([ApiResponse] -> ShowS)
    -> Show ApiResponse
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ApiResponse -> ShowS
    showsPrec :: Int -> ApiResponse -> ShowS
    $cshow :: ApiResponse -> [Char]
    show :: ApiResponse -> [Char]
    $cshowList :: [ApiResponse] -> ShowS
    showList :: [ApiResponse] -> ShowS
    P.Show, ApiResponse -> ApiResponse -> Bool
    (ApiResponse -> ApiResponse -> Bool)
    -> (ApiResponse -> ApiResponse -> Bool) -> Eq ApiResponse
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ApiResponse -> ApiResponse -> Bool
    == :: ApiResponse -> ApiResponse -> Bool
    $c/= :: ApiResponse -> ApiResponse -> Bool
    /= :: ApiResponse -> ApiResponse -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON ApiResponse
    instance A.FromJSON ApiResponse where
      parseJSON :: Value -> Parser ApiResponse
    parseJSON = [Char]
    -> (Object -> Parser ApiResponse) -> Value -> Parser ApiResponse
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "ApiResponse" ((Object -> Parser ApiResponse) -> Value -> Parser ApiResponse)
    -> (Object -> Parser ApiResponse) -> Value -> Parser ApiResponse
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Int -> Maybe Text -> Maybe Text -> ApiResponse
    ApiResponse
          (Maybe Int -> Maybe Text -> Maybe Text -> ApiResponse)
    -> Parser (Maybe Int)
    -> Parser (Maybe Text -> Maybe Text -> ApiResponse)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "code")
          Parser (Maybe Text -> Maybe Text -> ApiResponse)
    -> Parser (Maybe Text) -> Parser (Maybe Text -> ApiResponse)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "type")
          Parser (Maybe Text -> ApiResponse)
    -> Parser (Maybe Text) -> Parser ApiResponse
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "message")

    -- | ToJSON ApiResponse
    instance A.ToJSON ApiResponse where
      toJSON :: ApiResponse -> Value
    toJSON ApiResponse {Maybe Int
    Maybe Text
    apiResponseCode :: ApiResponse -> Maybe Int
    apiResponseType :: ApiResponse -> Maybe Text
    apiResponseMessage :: ApiResponse -> Maybe Text
    apiResponseCode :: Maybe Int
    apiResponseType :: Maybe Text
    apiResponseMessage :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "code" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    apiResponseCode
          , Key
    "type" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    apiResponseType
          , Key
    "message" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    apiResponseMessage
          ]

    -- | Construct a value of type 'ApiResponse' (by applying it's required fields, if any)
    mkApiResponse
      :: ApiResponse
    mkApiResponse :: ApiResponse
    mkApiResponse =
      ApiResponse
      { apiResponseCode :: Maybe Int
    apiResponseCode = Maybe Int
    forall a. Maybe a
    Nothing
      , apiResponseType :: Maybe Text
    apiResponseType = Maybe Text
    forall a. Maybe a
    Nothing
      , apiResponseMessage :: Maybe Text
    apiResponseMessage = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** ArrayOfArrayOfNumberOnly
    -- | ArrayOfArrayOfNumberOnly
    data ArrayOfArrayOfNumberOnly = ArrayOfArrayOfNumberOnly
      { ArrayOfArrayOfNumberOnly -> Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber :: !(Maybe [[Double]]) -- ^ "ArrayArrayNumber"
      } deriving (Int -> ArrayOfArrayOfNumberOnly -> ShowS
    [ArrayOfArrayOfNumberOnly] -> ShowS
    ArrayOfArrayOfNumberOnly -> [Char]
    (Int -> ArrayOfArrayOfNumberOnly -> ShowS)
    -> (ArrayOfArrayOfNumberOnly -> [Char])
    -> ([ArrayOfArrayOfNumberOnly] -> ShowS)
    -> Show ArrayOfArrayOfNumberOnly
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ArrayOfArrayOfNumberOnly -> ShowS
    showsPrec :: Int -> ArrayOfArrayOfNumberOnly -> ShowS
    $cshow :: ArrayOfArrayOfNumberOnly -> [Char]
    show :: ArrayOfArrayOfNumberOnly -> [Char]
    $cshowList :: [ArrayOfArrayOfNumberOnly] -> ShowS
    showList :: [ArrayOfArrayOfNumberOnly] -> ShowS
    P.Show, ArrayOfArrayOfNumberOnly -> ArrayOfArrayOfNumberOnly -> Bool
    (ArrayOfArrayOfNumberOnly -> ArrayOfArrayOfNumberOnly -> Bool)
    -> (ArrayOfArrayOfNumberOnly -> ArrayOfArrayOfNumberOnly -> Bool)
    -> Eq ArrayOfArrayOfNumberOnly
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ArrayOfArrayOfNumberOnly -> ArrayOfArrayOfNumberOnly -> Bool
    == :: ArrayOfArrayOfNumberOnly -> ArrayOfArrayOfNumberOnly -> Bool
    $c/= :: ArrayOfArrayOfNumberOnly -> ArrayOfArrayOfNumberOnly -> Bool
    /= :: ArrayOfArrayOfNumberOnly -> ArrayOfArrayOfNumberOnly -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON ArrayOfArrayOfNumberOnly
    instance A.FromJSON ArrayOfArrayOfNumberOnly where
      parseJSON :: Value -> Parser ArrayOfArrayOfNumberOnly
    parseJSON = [Char]
    -> (Object -> Parser ArrayOfArrayOfNumberOnly)
    -> Value
    -> Parser ArrayOfArrayOfNumberOnly
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "ArrayOfArrayOfNumberOnly" ((Object -> Parser ArrayOfArrayOfNumberOnly)
     -> Value -> Parser ArrayOfArrayOfNumberOnly)
    -> (Object -> Parser ArrayOfArrayOfNumberOnly)
    -> Value
    -> Parser ArrayOfArrayOfNumberOnly
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe [[Double]] -> ArrayOfArrayOfNumberOnly
    ArrayOfArrayOfNumberOnly
          (Maybe [[Double]] -> ArrayOfArrayOfNumberOnly)
    -> Parser (Maybe [[Double]]) -> Parser ArrayOfArrayOfNumberOnly
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe [[Double]])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "ArrayArrayNumber")

    -- | ToJSON ArrayOfArrayOfNumberOnly
    instance A.ToJSON ArrayOfArrayOfNumberOnly where
      toJSON :: ArrayOfArrayOfNumberOnly -> Value
    toJSON ArrayOfArrayOfNumberOnly {Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber :: ArrayOfArrayOfNumberOnly -> Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber :: Maybe [[Double]]
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "ArrayArrayNumber" Key -> Maybe [[Double]] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber
          ]

    -- | Construct a value of type 'ArrayOfArrayOfNumberOnly' (by applying it's required fields, if any)
    mkArrayOfArrayOfNumberOnly
      :: ArrayOfArrayOfNumberOnly
    mkArrayOfArrayOfNumberOnly :: ArrayOfArrayOfNumberOnly
    mkArrayOfArrayOfNumberOnly =
      ArrayOfArrayOfNumberOnly
      { arrayOfArrayOfNumberOnlyArrayArrayNumber :: Maybe [[Double]]
    arrayOfArrayOfNumberOnlyArrayArrayNumber = Maybe [[Double]]
    forall a. Maybe a
    Nothing
      }

    -- ** ArrayOfNumberOnly
    -- | ArrayOfNumberOnly
    data ArrayOfNumberOnly = ArrayOfNumberOnly
      { ArrayOfNumberOnly -> Maybe [Double]
    arrayOfNumberOnlyArrayNumber :: !(Maybe [Double]) -- ^ "ArrayNumber"
      } deriving (Int -> ArrayOfNumberOnly -> ShowS
    [ArrayOfNumberOnly] -> ShowS
    ArrayOfNumberOnly -> [Char]
    (Int -> ArrayOfNumberOnly -> ShowS)
    -> (ArrayOfNumberOnly -> [Char])
    -> ([ArrayOfNumberOnly] -> ShowS)
    -> Show ArrayOfNumberOnly
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ArrayOfNumberOnly -> ShowS
    showsPrec :: Int -> ArrayOfNumberOnly -> ShowS
    $cshow :: ArrayOfNumberOnly -> [Char]
    show :: ArrayOfNumberOnly -> [Char]
    $cshowList :: [ArrayOfNumberOnly] -> ShowS
    showList :: [ArrayOfNumberOnly] -> ShowS
    P.Show, ArrayOfNumberOnly -> ArrayOfNumberOnly -> Bool
    (ArrayOfNumberOnly -> ArrayOfNumberOnly -> Bool)
    -> (ArrayOfNumberOnly -> ArrayOfNumberOnly -> Bool)
    -> Eq ArrayOfNumberOnly
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ArrayOfNumberOnly -> ArrayOfNumberOnly -> Bool
    == :: ArrayOfNumberOnly -> ArrayOfNumberOnly -> Bool
    $c/= :: ArrayOfNumberOnly -> ArrayOfNumberOnly -> Bool
    /= :: ArrayOfNumberOnly -> ArrayOfNumberOnly -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON ArrayOfNumberOnly
    instance A.FromJSON ArrayOfNumberOnly where
      parseJSON :: Value -> Parser ArrayOfNumberOnly
    parseJSON = [Char]
    -> (Object -> Parser ArrayOfNumberOnly)
    -> Value
    -> Parser ArrayOfNumberOnly
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "ArrayOfNumberOnly" ((Object -> Parser ArrayOfNumberOnly)
     -> Value -> Parser ArrayOfNumberOnly)
    -> (Object -> Parser ArrayOfNumberOnly)
    -> Value
    -> Parser ArrayOfNumberOnly
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe [Double] -> ArrayOfNumberOnly
    ArrayOfNumberOnly
          (Maybe [Double] -> ArrayOfNumberOnly)
    -> Parser (Maybe [Double]) -> Parser ArrayOfNumberOnly
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe [Double])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "ArrayNumber")

    -- | ToJSON ArrayOfNumberOnly
    instance A.ToJSON ArrayOfNumberOnly where
      toJSON :: ArrayOfNumberOnly -> Value
    toJSON ArrayOfNumberOnly {Maybe [Double]
    arrayOfNumberOnlyArrayNumber :: ArrayOfNumberOnly -> Maybe [Double]
    arrayOfNumberOnlyArrayNumber :: Maybe [Double]
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "ArrayNumber" Key -> Maybe [Double] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Double]
    arrayOfNumberOnlyArrayNumber
          ]

    -- | Construct a value of type 'ArrayOfNumberOnly' (by applying it's required fields, if any)
    mkArrayOfNumberOnly
      :: ArrayOfNumberOnly
    mkArrayOfNumberOnly :: ArrayOfNumberOnly
    mkArrayOfNumberOnly =
      ArrayOfNumberOnly
      { arrayOfNumberOnlyArrayNumber :: Maybe [Double]
    arrayOfNumberOnlyArrayNumber = Maybe [Double]
    forall a. Maybe a
    Nothing
      }

    -- ** ArrayTest
    -- | ArrayTest
    data ArrayTest = ArrayTest
      { ArrayTest -> Maybe [Text]
    arrayTestArrayOfString :: !(Maybe [Text]) -- ^ "array_of_string"
      , ArrayTest -> Maybe [[Integer]]
    arrayTestArrayArrayOfInteger :: !(Maybe [[Integer]]) -- ^ "array_array_of_integer"
      , ArrayTest -> Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfModel :: !(Maybe [[ReadOnlyFirst]]) -- ^ "array_array_of_model"
      } deriving (Int -> ArrayTest -> ShowS
    [ArrayTest] -> ShowS
    ArrayTest -> [Char]
    (Int -> ArrayTest -> ShowS)
    -> (ArrayTest -> [Char])
    -> ([ArrayTest] -> ShowS)
    -> Show ArrayTest
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ArrayTest -> ShowS
    showsPrec :: Int -> ArrayTest -> ShowS
    $cshow :: ArrayTest -> [Char]
    show :: ArrayTest -> [Char]
    $cshowList :: [ArrayTest] -> ShowS
    showList :: [ArrayTest] -> ShowS
    P.Show, ArrayTest -> ArrayTest -> Bool
    (ArrayTest -> ArrayTest -> Bool)
    -> (ArrayTest -> ArrayTest -> Bool) -> Eq ArrayTest
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ArrayTest -> ArrayTest -> Bool
    == :: ArrayTest -> ArrayTest -> Bool
    $c/= :: ArrayTest -> ArrayTest -> Bool
    /= :: ArrayTest -> ArrayTest -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON ArrayTest
    instance A.FromJSON ArrayTest where
      parseJSON :: Value -> Parser ArrayTest
    parseJSON = [Char] -> (Object -> Parser ArrayTest) -> Value -> Parser ArrayTest
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "ArrayTest" ((Object -> Parser ArrayTest) -> Value -> Parser ArrayTest)
    -> (Object -> Parser ArrayTest) -> Value -> Parser ArrayTest
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe [Text]
    -> Maybe [[Integer]] -> Maybe [[ReadOnlyFirst]] -> ArrayTest
    ArrayTest
          (Maybe [Text]
     -> Maybe [[Integer]] -> Maybe [[ReadOnlyFirst]] -> ArrayTest)
    -> Parser (Maybe [Text])
    -> Parser
         (Maybe [[Integer]] -> Maybe [[ReadOnlyFirst]] -> ArrayTest)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe [Text])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "array_of_string")
          Parser (Maybe [[Integer]] -> Maybe [[ReadOnlyFirst]] -> ArrayTest)
    -> Parser (Maybe [[Integer]])
    -> Parser (Maybe [[ReadOnlyFirst]] -> ArrayTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [[Integer]])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "array_array_of_integer")
          Parser (Maybe [[ReadOnlyFirst]] -> ArrayTest)
    -> Parser (Maybe [[ReadOnlyFirst]]) -> Parser ArrayTest
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [[ReadOnlyFirst]])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "array_array_of_model")

    -- | ToJSON ArrayTest
    instance A.ToJSON ArrayTest where
      toJSON :: ArrayTest -> Value
    toJSON ArrayTest {Maybe [[Integer]]
    Maybe [[ReadOnlyFirst]]
    Maybe [Text]
    arrayTestArrayOfString :: ArrayTest -> Maybe [Text]
    arrayTestArrayArrayOfInteger :: ArrayTest -> Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: ArrayTest -> Maybe [[ReadOnlyFirst]]
    arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "array_of_string" Key -> Maybe [Text] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Text]
    arrayTestArrayOfString
          , Key
    "array_array_of_integer" Key -> Maybe [[Integer]] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [[Integer]]
    arrayTestArrayArrayOfInteger
          , Key
    "array_array_of_model" Key -> Maybe [[ReadOnlyFirst]] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfModel
          ]

    -- | Construct a value of type 'ArrayTest' (by applying it's required fields, if any)
    mkArrayTest
      :: ArrayTest
    mkArrayTest :: ArrayTest
    mkArrayTest =
      ArrayTest
      { arrayTestArrayOfString :: Maybe [Text]
    arrayTestArrayOfString = Maybe [Text]
    forall a. Maybe a
    Nothing
      , arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
    arrayTestArrayArrayOfInteger = Maybe [[Integer]]
    forall a. Maybe a
    Nothing
      , arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    arrayTestArrayArrayOfModel = Maybe [[ReadOnlyFirst]]
    forall a. Maybe a
    Nothing
      }

    -- ** BigCat
    -- | BigCat
    data BigCat = BigCat
      { BigCat -> Text
    bigCatClassName :: !(Text) -- ^ /Required/ "className"
      , BigCat -> Maybe Text
    bigCatColor :: !(Maybe Text) -- ^ "color"
      , BigCat -> Maybe Bool
    bigCatDeclawed :: !(Maybe Bool) -- ^ "declawed"
      , BigCat -> Maybe E'Kind
    bigCatKind :: !(Maybe E'Kind) -- ^ "kind"
      } deriving (Int -> BigCat -> ShowS
    [BigCat] -> ShowS
    BigCat -> [Char]
    (Int -> BigCat -> ShowS)
    -> (BigCat -> [Char]) -> ([BigCat] -> ShowS) -> Show BigCat
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BigCat -> ShowS
    showsPrec :: Int -> BigCat -> ShowS
    $cshow :: BigCat -> [Char]
    show :: BigCat -> [Char]
    $cshowList :: [BigCat] -> ShowS
    showList :: [BigCat] -> ShowS
    P.Show, BigCat -> BigCat -> Bool
    (BigCat -> BigCat -> Bool)
    -> (BigCat -> BigCat -> Bool) -> Eq BigCat
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BigCat -> BigCat -> Bool
    == :: BigCat -> BigCat -> Bool
    $c/= :: BigCat -> BigCat -> Bool
    /= :: BigCat -> BigCat -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON BigCat
    instance A.FromJSON BigCat where
      parseJSON :: Value -> Parser BigCat
    parseJSON = [Char] -> (Object -> Parser BigCat) -> Value -> Parser BigCat
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "BigCat" ((Object -> Parser BigCat) -> Value -> Parser BigCat)
    -> (Object -> Parser BigCat) -> Value -> Parser BigCat
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Text -> Maybe Text -> Maybe Bool -> Maybe E'Kind -> BigCat
    BigCat
          (Text -> Maybe Text -> Maybe Bool -> Maybe E'Kind -> BigCat)
    -> Parser Text
    -> Parser (Maybe Text -> Maybe Bool -> Maybe E'Kind -> BigCat)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser Text
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "className")
          Parser (Maybe Text -> Maybe Bool -> Maybe E'Kind -> BigCat)
    -> Parser (Maybe Text)
    -> Parser (Maybe Bool -> Maybe E'Kind -> BigCat)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "color")
          Parser (Maybe Bool -> Maybe E'Kind -> BigCat)
    -> Parser (Maybe Bool) -> Parser (Maybe E'Kind -> BigCat)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Bool)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "declawed")
          Parser (Maybe E'Kind -> BigCat)
    -> Parser (Maybe E'Kind) -> Parser BigCat
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe E'Kind)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "kind")

    -- | ToJSON BigCat
    instance A.ToJSON BigCat where
      toJSON :: BigCat -> Value
    toJSON BigCat {Maybe Bool
    Maybe Text
    Maybe E'Kind
    Text
    bigCatClassName :: BigCat -> Text
    bigCatColor :: BigCat -> Maybe Text
    bigCatDeclawed :: BigCat -> Maybe Bool
    bigCatKind :: BigCat -> Maybe E'Kind
    bigCatClassName :: Text
    bigCatColor :: Maybe Text
    bigCatDeclawed :: Maybe Bool
    bigCatKind :: Maybe E'Kind
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "className" Key -> Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Text
    bigCatClassName
          , Key
    "color" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    bigCatColor
          , Key
    "declawed" Key -> Maybe Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Bool
    bigCatDeclawed
          , Key
    "kind" Key -> Maybe E'Kind -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe E'Kind
    bigCatKind
          ]

    -- | Construct a value of type 'BigCat' (by applying it's required fields, if any)
    mkBigCat
      :: Text -- ^ 'bigCatClassName'
      -> BigCat
    mkBigCat :: Text -> BigCat
    mkBigCat Text
    bigCatClassName =
      BigCat
      { Text
    bigCatClassName :: Text
    bigCatClassName :: Text
    bigCatClassName
      , bigCatColor :: Maybe Text
    bigCatColor = Maybe Text
    forall a. Maybe a
    Nothing
      , bigCatDeclawed :: Maybe Bool
    bigCatDeclawed = Maybe Bool
    forall a. Maybe a
    Nothing
      , bigCatKind :: Maybe E'Kind
    bigCatKind = Maybe E'Kind
    forall a. Maybe a
    Nothing
      }

    -- ** Capitalization
    -- | Capitalization
    data Capitalization = Capitalization
      { Capitalization -> Maybe Text
    capitalizationSmallCamel :: !(Maybe Text) -- ^ "smallCamel"
      , Capitalization -> Maybe Text
    capitalizationCapitalCamel :: !(Maybe Text) -- ^ "CapitalCamel"
      , Capitalization -> Maybe Text
    capitalizationSmallSnake :: !(Maybe Text) -- ^ "small_Snake"
      , Capitalization -> Maybe Text
    capitalizationCapitalSnake :: !(Maybe Text) -- ^ "Capital_Snake"
      , Capitalization -> Maybe Text
    capitalizationScaEthFlowPoints :: !(Maybe Text) -- ^ "SCA_ETH_Flow_Points"
      , Capitalization -> Maybe Text
    capitalizationAttName :: !(Maybe Text) -- ^ "ATT_NAME" - Name of the pet
      } deriving (Int -> Capitalization -> ShowS
    [Capitalization] -> ShowS
    Capitalization -> [Char]
    (Int -> Capitalization -> ShowS)
    -> (Capitalization -> [Char])
    -> ([Capitalization] -> ShowS)
    -> Show Capitalization
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Capitalization -> ShowS
    showsPrec :: Int -> Capitalization -> ShowS
    $cshow :: Capitalization -> [Char]
    show :: Capitalization -> [Char]
    $cshowList :: [Capitalization] -> ShowS
    showList :: [Capitalization] -> ShowS
    P.Show, Capitalization -> Capitalization -> Bool
    (Capitalization -> Capitalization -> Bool)
    -> (Capitalization -> Capitalization -> Bool) -> Eq Capitalization
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Capitalization -> Capitalization -> Bool
    == :: Capitalization -> Capitalization -> Bool
    $c/= :: Capitalization -> Capitalization -> Bool
    /= :: Capitalization -> Capitalization -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Capitalization
    instance A.FromJSON Capitalization where
      parseJSON :: Value -> Parser Capitalization
    parseJSON = [Char]
    -> (Object -> Parser Capitalization)
    -> Value
    -> Parser Capitalization
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Capitalization" ((Object -> Parser Capitalization)
     -> Value -> Parser Capitalization)
    -> (Object -> Parser Capitalization)
    -> Value
    -> Parser Capitalization
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> Capitalization
    Capitalization
          (Maybe Text
     -> Maybe Text
     -> Maybe Text
     -> Maybe Text
     -> Maybe Text
     -> Maybe Text
     -> Capitalization)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Capitalization)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "smallCamel")
          Parser
      (Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Capitalization)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Text
          -> Maybe Text -> Maybe Text -> Maybe Text -> Capitalization)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "CapitalCamel")
          Parser
      (Maybe Text
       -> Maybe Text -> Maybe Text -> Maybe Text -> Capitalization)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Text -> Maybe Text -> Maybe Text -> Capitalization)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "small_Snake")
          Parser (Maybe Text -> Maybe Text -> Maybe Text -> Capitalization)
    -> Parser (Maybe Text)
    -> Parser (Maybe Text -> Maybe Text -> Capitalization)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "Capital_Snake")
          Parser (Maybe Text -> Maybe Text -> Capitalization)
    -> Parser (Maybe Text) -> Parser (Maybe Text -> Capitalization)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "SCA_ETH_Flow_Points")
          Parser (Maybe Text -> Capitalization)
    -> Parser (Maybe Text) -> Parser Capitalization
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "ATT_NAME")

    -- | ToJSON Capitalization
    instance A.ToJSON Capitalization where
      toJSON :: Capitalization -> Value
    toJSON Capitalization {Maybe Text
    capitalizationSmallCamel :: Capitalization -> Maybe Text
    capitalizationCapitalCamel :: Capitalization -> Maybe Text
    capitalizationSmallSnake :: Capitalization -> Maybe Text
    capitalizationCapitalSnake :: Capitalization -> Maybe Text
    capitalizationScaEthFlowPoints :: Capitalization -> Maybe Text
    capitalizationAttName :: Capitalization -> Maybe Text
    capitalizationSmallCamel :: Maybe Text
    capitalizationCapitalCamel :: Maybe Text
    capitalizationSmallSnake :: Maybe Text
    capitalizationCapitalSnake :: Maybe Text
    capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationAttName :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "smallCamel" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    capitalizationSmallCamel
          , Key
    "CapitalCamel" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    capitalizationCapitalCamel
          , Key
    "small_Snake" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    capitalizationSmallSnake
          , Key
    "Capital_Snake" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    capitalizationCapitalSnake
          , Key
    "SCA_ETH_Flow_Points" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    capitalizationScaEthFlowPoints
          , Key
    "ATT_NAME" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    capitalizationAttName
          ]

    -- | Construct a value of type 'Capitalization' (by applying it's required fields, if any)
    mkCapitalization
      :: Capitalization
    mkCapitalization :: Capitalization
    mkCapitalization =
      Capitalization
      { capitalizationSmallCamel :: Maybe Text
    capitalizationSmallCamel = Maybe Text
    forall a. Maybe a
    Nothing
      , capitalizationCapitalCamel :: Maybe Text
    capitalizationCapitalCamel = Maybe Text
    forall a. Maybe a
    Nothing
      , capitalizationSmallSnake :: Maybe Text
    capitalizationSmallSnake = Maybe Text
    forall a. Maybe a
    Nothing
      , capitalizationCapitalSnake :: Maybe Text
    capitalizationCapitalSnake = Maybe Text
    forall a. Maybe a
    Nothing
      , capitalizationScaEthFlowPoints :: Maybe Text
    capitalizationScaEthFlowPoints = Maybe Text
    forall a. Maybe a
    Nothing
      , capitalizationAttName :: Maybe Text
    capitalizationAttName = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** Cat
    -- | Cat
    data Cat = Cat
      { Cat -> Text
    catClassName :: !(Text) -- ^ /Required/ "className"
      , Cat -> Maybe Text
    catColor :: !(Maybe Text) -- ^ "color"
      , Cat -> Maybe Bool
    catDeclawed :: !(Maybe Bool) -- ^ "declawed"
      } deriving (Int -> Cat -> ShowS
    [Cat] -> ShowS
    Cat -> [Char]
    (Int -> Cat -> ShowS)
    -> (Cat -> [Char]) -> ([Cat] -> ShowS) -> Show Cat
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Cat -> ShowS
    showsPrec :: Int -> Cat -> ShowS
    $cshow :: Cat -> [Char]
    show :: Cat -> [Char]
    $cshowList :: [Cat] -> ShowS
    showList :: [Cat] -> ShowS
    P.Show, Cat -> Cat -> Bool
    (Cat -> Cat -> Bool) -> (Cat -> Cat -> Bool) -> Eq Cat
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Cat -> Cat -> Bool
    == :: Cat -> Cat -> Bool
    $c/= :: Cat -> Cat -> Bool
    /= :: Cat -> Cat -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Cat
    instance A.FromJSON Cat where
      parseJSON :: Value -> Parser Cat
    parseJSON = [Char] -> (Object -> Parser Cat) -> Value -> Parser Cat
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Cat" ((Object -> Parser Cat) -> Value -> Parser Cat)
    -> (Object -> Parser Cat) -> Value -> Parser Cat
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Text -> Maybe Text -> Maybe Bool -> Cat
    Cat
          (Text -> Maybe Text -> Maybe Bool -> Cat)
    -> Parser Text -> Parser (Maybe Text -> Maybe Bool -> Cat)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser Text
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "className")
          Parser (Maybe Text -> Maybe Bool -> Cat)
    -> Parser (Maybe Text) -> Parser (Maybe Bool -> Cat)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "color")
          Parser (Maybe Bool -> Cat) -> Parser (Maybe Bool) -> Parser Cat
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Bool)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "declawed")

    -- | ToJSON Cat
    instance A.ToJSON Cat where
      toJSON :: Cat -> Value
    toJSON Cat {Maybe Bool
    Maybe Text
    Text
    catClassName :: Cat -> Text
    catColor :: Cat -> Maybe Text
    catDeclawed :: Cat -> Maybe Bool
    catClassName :: Text
    catColor :: Maybe Text
    catDeclawed :: Maybe Bool
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "className" Key -> Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Text
    catClassName
          , Key
    "color" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    catColor
          , Key
    "declawed" Key -> Maybe Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Bool
    catDeclawed
          ]

    -- | Construct a value of type 'Cat' (by applying it's required fields, if any)
    mkCat
      :: Text -- ^ 'catClassName'
      -> Cat
    mkCat :: Text -> Cat
    mkCat Text
    catClassName =
      Cat
      { Text
    catClassName :: Text
    catClassName :: Text
    catClassName
      , catColor :: Maybe Text
    catColor = Maybe Text
    forall a. Maybe a
    Nothing
      , catDeclawed :: Maybe Bool
    catDeclawed = Maybe Bool
    forall a. Maybe a
    Nothing
      }

    -- ** Category
    -- | Category
    data Category = Category
      { Category -> Maybe Integer
    categoryId :: !(Maybe Integer) -- ^ "id"
      , Category -> Text
    categoryName :: !(Text) -- ^ /Required/ "name"
      } deriving (Int -> Category -> ShowS
    [Category] -> ShowS
    Category -> [Char]
    (Int -> Category -> ShowS)
    -> (Category -> [Char]) -> ([Category] -> ShowS) -> Show Category
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Category -> ShowS
    showsPrec :: Int -> Category -> ShowS
    $cshow :: Category -> [Char]
    show :: Category -> [Char]
    $cshowList :: [Category] -> ShowS
    showList :: [Category] -> ShowS
    P.Show, Category -> Category -> Bool
    (Category -> Category -> Bool)
    -> (Category -> Category -> Bool) -> Eq Category
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Category -> Category -> Bool
    == :: Category -> Category -> Bool
    $c/= :: Category -> Category -> Bool
    /= :: Category -> Category -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Category
    instance A.FromJSON Category where
      parseJSON :: Value -> Parser Category
    parseJSON = [Char] -> (Object -> Parser Category) -> Value -> Parser Category
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Category" ((Object -> Parser Category) -> Value -> Parser Category)
    -> (Object -> Parser Category) -> Value -> Parser Category
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Integer -> Text -> Category
    Category
          (Maybe Integer -> Text -> Category)
    -> Parser (Maybe Integer) -> Parser (Text -> Category)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Integer)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "id")
          Parser (Text -> Category) -> Parser Text -> Parser Category
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Text
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "name")

    -- | ToJSON Category
    instance A.ToJSON Category where
      toJSON :: Category -> Value
    toJSON Category {Maybe Integer
    Text
    categoryId :: Category -> Maybe Integer
    categoryName :: Category -> Text
    categoryId :: Maybe Integer
    categoryName :: Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "id" Key -> Maybe Integer -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Integer
    categoryId
          , Key
    "name" Key -> Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Text
    categoryName
          ]

    -- | Construct a value of type 'Category' (by applying it's required fields, if any)
    mkCategory
      :: Text -- ^ 'categoryName'
      -> Category
    mkCategory :: Text -> Category
    mkCategory Text
    categoryName =
      Category
      { categoryId :: Maybe Integer
    categoryId = Maybe Integer
    forall a. Maybe a
    Nothing
      , Text
    categoryName :: Text
    categoryName :: Text
    categoryName
      }

    -- ** ClassModel
    -- | ClassModel
    -- Model for testing model with \"_class\" property
    data ClassModel = ClassModel
      { ClassModel -> Maybe Text
    classModelClass :: !(Maybe Text) -- ^ "_class"
      } deriving (Int -> ClassModel -> ShowS
    [ClassModel] -> ShowS
    ClassModel -> [Char]
    (Int -> ClassModel -> ShowS)
    -> (ClassModel -> [Char])
    -> ([ClassModel] -> ShowS)
    -> Show ClassModel
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ClassModel -> ShowS
    showsPrec :: Int -> ClassModel -> ShowS
    $cshow :: ClassModel -> [Char]
    show :: ClassModel -> [Char]
    $cshowList :: [ClassModel] -> ShowS
    showList :: [ClassModel] -> ShowS
    P.Show, ClassModel -> ClassModel -> Bool
    (ClassModel -> ClassModel -> Bool)
    -> (ClassModel -> ClassModel -> Bool) -> Eq ClassModel
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ClassModel -> ClassModel -> Bool
    == :: ClassModel -> ClassModel -> Bool
    $c/= :: ClassModel -> ClassModel -> Bool
    /= :: ClassModel -> ClassModel -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON ClassModel
    instance A.FromJSON ClassModel where
      parseJSON :: Value -> Parser ClassModel
    parseJSON = [Char]
    -> (Object -> Parser ClassModel) -> Value -> Parser ClassModel
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "ClassModel" ((Object -> Parser ClassModel) -> Value -> Parser ClassModel)
    -> (Object -> Parser ClassModel) -> Value -> Parser ClassModel
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> ClassModel
    ClassModel
          (Maybe Text -> ClassModel)
    -> Parser (Maybe Text) -> Parser ClassModel
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "_class")

    -- | ToJSON ClassModel
    instance A.ToJSON ClassModel where
      toJSON :: ClassModel -> Value
    toJSON ClassModel {Maybe Text
    classModelClass :: ClassModel -> Maybe Text
    classModelClass :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "_class" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    classModelClass
          ]

    -- | Construct a value of type 'ClassModel' (by applying it's required fields, if any)
    mkClassModel
      :: ClassModel
    mkClassModel :: ClassModel
    mkClassModel =
      ClassModel
      { classModelClass :: Maybe Text
    classModelClass = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** Client
    -- | Client
    data Client = Client
      { Client -> Maybe Text
    clientClient :: !(Maybe Text) -- ^ "client"
      } deriving (Int -> Client -> ShowS
    [Client] -> ShowS
    Client -> [Char]
    (Int -> Client -> ShowS)
    -> (Client -> [Char]) -> ([Client] -> ShowS) -> Show Client
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Client -> ShowS
    showsPrec :: Int -> Client -> ShowS
    $cshow :: Client -> [Char]
    show :: Client -> [Char]
    $cshowList :: [Client] -> ShowS
    showList :: [Client] -> ShowS
    P.Show, Client -> Client -> Bool
    (Client -> Client -> Bool)
    -> (Client -> Client -> Bool) -> Eq Client
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Client -> Client -> Bool
    == :: Client -> Client -> Bool
    $c/= :: Client -> Client -> Bool
    /= :: Client -> Client -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Client
    instance A.FromJSON Client where
      parseJSON :: Value -> Parser Client
    parseJSON = [Char] -> (Object -> Parser Client) -> Value -> Parser Client
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Client" ((Object -> Parser Client) -> Value -> Parser Client)
    -> (Object -> Parser Client) -> Value -> Parser Client
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> Client
    Client
          (Maybe Text -> Client) -> Parser (Maybe Text) -> Parser Client
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "client")

    -- | ToJSON Client
    instance A.ToJSON Client where
      toJSON :: Client -> Value
    toJSON Client {Maybe Text
    clientClient :: Client -> Maybe Text
    clientClient :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "client" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    clientClient
          ]

    -- | Construct a value of type 'Client' (by applying it's required fields, if any)
    mkClient
      :: Client
    mkClient :: Client
    mkClient =
      Client
      { clientClient :: Maybe Text
    clientClient = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** Dog
    -- | Dog
    data Dog = Dog
      { Dog -> Text
    dogClassName :: !(Text) -- ^ /Required/ "className"
      , Dog -> Maybe Text
    dogColor :: !(Maybe Text) -- ^ "color"
      , Dog -> Maybe Text
    dogBreed :: !(Maybe Text) -- ^ "breed"
      } deriving (Int -> Dog -> ShowS
    [Dog] -> ShowS
    Dog -> [Char]
    (Int -> Dog -> ShowS)
    -> (Dog -> [Char]) -> ([Dog] -> ShowS) -> Show Dog
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Dog -> ShowS
    showsPrec :: Int -> Dog -> ShowS
    $cshow :: Dog -> [Char]
    show :: Dog -> [Char]
    $cshowList :: [Dog] -> ShowS
    showList :: [Dog] -> ShowS
    P.Show, Dog -> Dog -> Bool
    (Dog -> Dog -> Bool) -> (Dog -> Dog -> Bool) -> Eq Dog
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Dog -> Dog -> Bool
    == :: Dog -> Dog -> Bool
    $c/= :: Dog -> Dog -> Bool
    /= :: Dog -> Dog -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Dog
    instance A.FromJSON Dog where
      parseJSON :: Value -> Parser Dog
    parseJSON = [Char] -> (Object -> Parser Dog) -> Value -> Parser Dog
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Dog" ((Object -> Parser Dog) -> Value -> Parser Dog)
    -> (Object -> Parser Dog) -> Value -> Parser Dog
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Text -> Maybe Text -> Maybe Text -> Dog
    Dog
          (Text -> Maybe Text -> Maybe Text -> Dog)
    -> Parser Text -> Parser (Maybe Text -> Maybe Text -> Dog)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser Text
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "className")
          Parser (Maybe Text -> Maybe Text -> Dog)
    -> Parser (Maybe Text) -> Parser (Maybe Text -> Dog)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "color")
          Parser (Maybe Text -> Dog) -> Parser (Maybe Text) -> Parser Dog
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "breed")

    -- | ToJSON Dog
    instance A.ToJSON Dog where
      toJSON :: Dog -> Value
    toJSON Dog {Maybe Text
    Text
    dogClassName :: Dog -> Text
    dogColor :: Dog -> Maybe Text
    dogBreed :: Dog -> Maybe Text
    dogClassName :: Text
    dogColor :: Maybe Text
    dogBreed :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "className" Key -> Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Text
    dogClassName
          , Key
    "color" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    dogColor
          , Key
    "breed" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    dogBreed
          ]

    -- | Construct a value of type 'Dog' (by applying it's required fields, if any)
    mkDog
      :: Text -- ^ 'dogClassName'
      -> Dog
    mkDog :: Text -> Dog
    mkDog Text
    dogClassName =
      Dog
      { Text
    dogClassName :: Text
    dogClassName :: Text
    dogClassName
      , dogColor :: Maybe Text
    dogColor = Maybe Text
    forall a. Maybe a
    Nothing
      , dogBreed :: Maybe Text
    dogBreed = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** EnumArrays
    -- | EnumArrays
    data EnumArrays = EnumArrays
      { EnumArrays -> Maybe E'JustSymbol
    enumArraysJustSymbol :: !(Maybe E'JustSymbol) -- ^ "just_symbol"
      , EnumArrays -> Maybe [E'ArrayEnum]
    enumArraysArrayEnum :: !(Maybe [E'ArrayEnum]) -- ^ "array_enum"
      } deriving (Int -> EnumArrays -> ShowS
    [EnumArrays] -> ShowS
    EnumArrays -> [Char]
    (Int -> EnumArrays -> ShowS)
    -> (EnumArrays -> [Char])
    -> ([EnumArrays] -> ShowS)
    -> Show EnumArrays
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumArrays -> ShowS
    showsPrec :: Int -> EnumArrays -> ShowS
    $cshow :: EnumArrays -> [Char]
    show :: EnumArrays -> [Char]
    $cshowList :: [EnumArrays] -> ShowS
    showList :: [EnumArrays] -> ShowS
    P.Show, EnumArrays -> EnumArrays -> Bool
    (EnumArrays -> EnumArrays -> Bool)
    -> (EnumArrays -> EnumArrays -> Bool) -> Eq EnumArrays
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumArrays -> EnumArrays -> Bool
    == :: EnumArrays -> EnumArrays -> Bool
    $c/= :: EnumArrays -> EnumArrays -> Bool
    /= :: EnumArrays -> EnumArrays -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON EnumArrays
    instance A.FromJSON EnumArrays where
      parseJSON :: Value -> Parser EnumArrays
    parseJSON = [Char]
    -> (Object -> Parser EnumArrays) -> Value -> Parser EnumArrays
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "EnumArrays" ((Object -> Parser EnumArrays) -> Value -> Parser EnumArrays)
    -> (Object -> Parser EnumArrays) -> Value -> Parser EnumArrays
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe E'JustSymbol -> Maybe [E'ArrayEnum] -> EnumArrays
    EnumArrays
          (Maybe E'JustSymbol -> Maybe [E'ArrayEnum] -> EnumArrays)
    -> Parser (Maybe E'JustSymbol)
    -> Parser (Maybe [E'ArrayEnum] -> EnumArrays)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe E'JustSymbol)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "just_symbol")
          Parser (Maybe [E'ArrayEnum] -> EnumArrays)
    -> Parser (Maybe [E'ArrayEnum]) -> Parser EnumArrays
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [E'ArrayEnum])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "array_enum")

    -- | ToJSON EnumArrays
    instance A.ToJSON EnumArrays where
      toJSON :: EnumArrays -> Value
    toJSON EnumArrays {Maybe [E'ArrayEnum]
    Maybe E'JustSymbol
    enumArraysJustSymbol :: EnumArrays -> Maybe E'JustSymbol
    enumArraysArrayEnum :: EnumArrays -> Maybe [E'ArrayEnum]
    enumArraysJustSymbol :: Maybe E'JustSymbol
    enumArraysArrayEnum :: Maybe [E'ArrayEnum]
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "just_symbol" Key -> Maybe E'JustSymbol -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe E'JustSymbol
    enumArraysJustSymbol
          , Key
    "array_enum" Key -> Maybe [E'ArrayEnum] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [E'ArrayEnum]
    enumArraysArrayEnum
          ]

    -- | Construct a value of type 'EnumArrays' (by applying it's required fields, if any)
    mkEnumArrays
      :: EnumArrays
    mkEnumArrays :: EnumArrays
    mkEnumArrays =
      EnumArrays
      { enumArraysJustSymbol :: Maybe E'JustSymbol
    enumArraysJustSymbol = Maybe E'JustSymbol
    forall a. Maybe a
    Nothing
      , enumArraysArrayEnum :: Maybe [E'ArrayEnum]
    enumArraysArrayEnum = Maybe [E'ArrayEnum]
    forall a. Maybe a
    Nothing
      }

    -- ** EnumTest
    -- | EnumTest
    data EnumTest = EnumTest
      { EnumTest -> Maybe E'EnumString
    enumTestEnumString :: !(Maybe E'EnumString) -- ^ "enum_string"
      , EnumTest -> E'EnumString
    enumTestEnumStringRequired :: !(E'EnumString) -- ^ /Required/ "enum_string_required"
      , EnumTest -> Maybe E'EnumInteger
    enumTestEnumInteger :: !(Maybe E'EnumInteger) -- ^ "enum_integer"
      , EnumTest -> Maybe E'EnumNumber
    enumTestEnumNumber :: !(Maybe E'EnumNumber) -- ^ "enum_number"
      , EnumTest -> Maybe OuterEnum
    enumTestOuterEnum :: !(Maybe OuterEnum) -- ^ "outerEnum"
      } deriving (Int -> EnumTest -> ShowS
    [EnumTest] -> ShowS
    EnumTest -> [Char]
    (Int -> EnumTest -> ShowS)
    -> (EnumTest -> [Char]) -> ([EnumTest] -> ShowS) -> Show EnumTest
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumTest -> ShowS
    showsPrec :: Int -> EnumTest -> ShowS
    $cshow :: EnumTest -> [Char]
    show :: EnumTest -> [Char]
    $cshowList :: [EnumTest] -> ShowS
    showList :: [EnumTest] -> ShowS
    P.Show, EnumTest -> EnumTest -> Bool
    (EnumTest -> EnumTest -> Bool)
    -> (EnumTest -> EnumTest -> Bool) -> Eq EnumTest
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumTest -> EnumTest -> Bool
    == :: EnumTest -> EnumTest -> Bool
    $c/= :: EnumTest -> EnumTest -> Bool
    /= :: EnumTest -> EnumTest -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON EnumTest
    instance A.FromJSON EnumTest where
      parseJSON :: Value -> Parser EnumTest
    parseJSON = [Char] -> (Object -> Parser EnumTest) -> Value -> Parser EnumTest
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "EnumTest" ((Object -> Parser EnumTest) -> Value -> Parser EnumTest)
    -> (Object -> Parser EnumTest) -> Value -> Parser EnumTest
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe E'EnumString
    -> E'EnumString
    -> Maybe E'EnumInteger
    -> Maybe E'EnumNumber
    -> Maybe OuterEnum
    -> EnumTest
    EnumTest
          (Maybe E'EnumString
     -> E'EnumString
     -> Maybe E'EnumInteger
     -> Maybe E'EnumNumber
     -> Maybe OuterEnum
     -> EnumTest)
    -> Parser (Maybe E'EnumString)
    -> Parser
         (E'EnumString
          -> Maybe E'EnumInteger
          -> Maybe E'EnumNumber
          -> Maybe OuterEnum
          -> EnumTest)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe E'EnumString)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "enum_string")
          Parser
      (E'EnumString
       -> Maybe E'EnumInteger
       -> Maybe E'EnumNumber
       -> Maybe OuterEnum
       -> EnumTest)
    -> Parser E'EnumString
    -> Parser
         (Maybe E'EnumInteger
          -> Maybe E'EnumNumber -> Maybe OuterEnum -> EnumTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser E'EnumString
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "enum_string_required")
          Parser
      (Maybe E'EnumInteger
       -> Maybe E'EnumNumber -> Maybe OuterEnum -> EnumTest)
    -> Parser (Maybe E'EnumInteger)
    -> Parser (Maybe E'EnumNumber -> Maybe OuterEnum -> EnumTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe E'EnumInteger)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "enum_integer")
          Parser (Maybe E'EnumNumber -> Maybe OuterEnum -> EnumTest)
    -> Parser (Maybe E'EnumNumber)
    -> Parser (Maybe OuterEnum -> EnumTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe E'EnumNumber)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "enum_number")
          Parser (Maybe OuterEnum -> EnumTest)
    -> Parser (Maybe OuterEnum) -> Parser EnumTest
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe OuterEnum)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "outerEnum")

    -- | ToJSON EnumTest
    instance A.ToJSON EnumTest where
      toJSON :: EnumTest -> Value
    toJSON EnumTest {Maybe OuterEnum
    Maybe E'EnumString
    Maybe E'EnumNumber
    Maybe E'EnumInteger
    E'EnumString
    enumTestEnumString :: EnumTest -> Maybe E'EnumString
    enumTestEnumStringRequired :: EnumTest -> E'EnumString
    enumTestEnumInteger :: EnumTest -> Maybe E'EnumInteger
    enumTestEnumNumber :: EnumTest -> Maybe E'EnumNumber
    enumTestOuterEnum :: EnumTest -> Maybe OuterEnum
    enumTestEnumString :: Maybe E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestOuterEnum :: Maybe OuterEnum
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "enum_string" Key -> Maybe E'EnumString -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe E'EnumString
    enumTestEnumString
          , Key
    "enum_string_required" Key -> E'EnumString -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= E'EnumString
    enumTestEnumStringRequired
          , Key
    "enum_integer" Key -> Maybe E'EnumInteger -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe E'EnumInteger
    enumTestEnumInteger
          , Key
    "enum_number" Key -> Maybe E'EnumNumber -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe E'EnumNumber
    enumTestEnumNumber
          , Key
    "outerEnum" Key -> Maybe OuterEnum -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe OuterEnum
    enumTestOuterEnum
          ]

    -- | Construct a value of type 'EnumTest' (by applying it's required fields, if any)
    mkEnumTest
      :: E'EnumString -- ^ 'enumTestEnumStringRequired'
      -> EnumTest
    mkEnumTest :: E'EnumString -> EnumTest
    mkEnumTest E'EnumString
    enumTestEnumStringRequired =
      EnumTest
      { enumTestEnumString :: Maybe E'EnumString
    enumTestEnumString = Maybe E'EnumString
    forall a. Maybe a
    Nothing
      , E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumStringRequired :: E'EnumString
    enumTestEnumStringRequired
      , enumTestEnumInteger :: Maybe E'EnumInteger
    enumTestEnumInteger = Maybe E'EnumInteger
    forall a. Maybe a
    Nothing
      , enumTestEnumNumber :: Maybe E'EnumNumber
    enumTestEnumNumber = Maybe E'EnumNumber
    forall a. Maybe a
    Nothing
      , enumTestOuterEnum :: Maybe OuterEnum
    enumTestOuterEnum = Maybe OuterEnum
    forall a. Maybe a
    Nothing
      }

    -- ** File
    -- | File
    -- Must be named `File` for test.
    data File = File
      { File -> Maybe Text
    fileSourceUri :: !(Maybe Text) -- ^ "sourceURI" - Test capitalization
      } deriving (Int -> File -> ShowS
    [File] -> ShowS
    File -> [Char]
    (Int -> File -> ShowS)
    -> (File -> [Char]) -> ([File] -> ShowS) -> Show File
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> File -> ShowS
    showsPrec :: Int -> File -> ShowS
    $cshow :: File -> [Char]
    show :: File -> [Char]
    $cshowList :: [File] -> ShowS
    showList :: [File] -> ShowS
    P.Show, File -> File -> Bool
    (File -> File -> Bool) -> (File -> File -> Bool) -> Eq File
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: File -> File -> Bool
    == :: File -> File -> Bool
    $c/= :: File -> File -> Bool
    /= :: File -> File -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON File
    instance A.FromJSON File where
      parseJSON :: Value -> Parser File
    parseJSON = [Char] -> (Object -> Parser File) -> Value -> Parser File
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "File" ((Object -> Parser File) -> Value -> Parser File)
    -> (Object -> Parser File) -> Value -> Parser File
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> File
    File
          (Maybe Text -> File) -> Parser (Maybe Text) -> Parser File
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "sourceURI")

    -- | ToJSON File
    instance A.ToJSON File where
      toJSON :: File -> Value
    toJSON File {Maybe Text
    fileSourceUri :: File -> Maybe Text
    fileSourceUri :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "sourceURI" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    fileSourceUri
          ]

    -- | Construct a value of type 'File' (by applying it's required fields, if any)
    mkFile
      :: File
    mkFile :: File
    mkFile =
      File
      { fileSourceUri :: Maybe Text
    fileSourceUri = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** FileSchemaTestClass
    -- | FileSchemaTestClass
    data FileSchemaTestClass = FileSchemaTestClass
      { FileSchemaTestClass -> Maybe File
    fileSchemaTestClassFile :: !(Maybe File) -- ^ "file"
      , FileSchemaTestClass -> Maybe [File]
    fileSchemaTestClassFiles :: !(Maybe [File]) -- ^ "files"
      } deriving (Int -> FileSchemaTestClass -> ShowS
    [FileSchemaTestClass] -> ShowS
    FileSchemaTestClass -> [Char]
    (Int -> FileSchemaTestClass -> ShowS)
    -> (FileSchemaTestClass -> [Char])
    -> ([FileSchemaTestClass] -> ShowS)
    -> Show FileSchemaTestClass
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FileSchemaTestClass -> ShowS
    showsPrec :: Int -> FileSchemaTestClass -> ShowS
    $cshow :: FileSchemaTestClass -> [Char]
    show :: FileSchemaTestClass -> [Char]
    $cshowList :: [FileSchemaTestClass] -> ShowS
    showList :: [FileSchemaTestClass] -> ShowS
    P.Show, FileSchemaTestClass -> FileSchemaTestClass -> Bool
    (FileSchemaTestClass -> FileSchemaTestClass -> Bool)
    -> (FileSchemaTestClass -> FileSchemaTestClass -> Bool)
    -> Eq FileSchemaTestClass
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileSchemaTestClass -> FileSchemaTestClass -> Bool
    == :: FileSchemaTestClass -> FileSchemaTestClass -> Bool
    $c/= :: FileSchemaTestClass -> FileSchemaTestClass -> Bool
    /= :: FileSchemaTestClass -> FileSchemaTestClass -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON FileSchemaTestClass
    instance A.FromJSON FileSchemaTestClass where
      parseJSON :: Value -> Parser FileSchemaTestClass
    parseJSON = [Char]
    -> (Object -> Parser FileSchemaTestClass)
    -> Value
    -> Parser FileSchemaTestClass
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "FileSchemaTestClass" ((Object -> Parser FileSchemaTestClass)
     -> Value -> Parser FileSchemaTestClass)
    -> (Object -> Parser FileSchemaTestClass)
    -> Value
    -> Parser FileSchemaTestClass
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe File -> Maybe [File] -> FileSchemaTestClass
    FileSchemaTestClass
          (Maybe File -> Maybe [File] -> FileSchemaTestClass)
    -> Parser (Maybe File)
    -> Parser (Maybe [File] -> FileSchemaTestClass)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe File)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "file")
          Parser (Maybe [File] -> FileSchemaTestClass)
    -> Parser (Maybe [File]) -> Parser FileSchemaTestClass
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [File])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "files")

    -- | ToJSON FileSchemaTestClass
    instance A.ToJSON FileSchemaTestClass where
      toJSON :: FileSchemaTestClass -> Value
    toJSON FileSchemaTestClass {Maybe [File]
    Maybe File
    fileSchemaTestClassFile :: FileSchemaTestClass -> Maybe File
    fileSchemaTestClassFiles :: FileSchemaTestClass -> Maybe [File]
    fileSchemaTestClassFile :: Maybe File
    fileSchemaTestClassFiles :: Maybe [File]
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "file" Key -> Maybe File -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe File
    fileSchemaTestClassFile
          , Key
    "files" Key -> Maybe [File] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [File]
    fileSchemaTestClassFiles
          ]

    -- | Construct a value of type 'FileSchemaTestClass' (by applying it's required fields, if any)
    mkFileSchemaTestClass
      :: FileSchemaTestClass
    mkFileSchemaTestClass :: FileSchemaTestClass
    mkFileSchemaTestClass =
      FileSchemaTestClass
      { fileSchemaTestClassFile :: Maybe File
    fileSchemaTestClassFile = Maybe File
    forall a. Maybe a
    Nothing
      , fileSchemaTestClassFiles :: Maybe [File]
    fileSchemaTestClassFiles = Maybe [File]
    forall a. Maybe a
    Nothing
      }

    -- ** FormatTest
    -- | FormatTest
    data FormatTest = FormatTest
      { FormatTest -> Maybe Int
    formatTestInteger :: !(Maybe Int) -- ^ "integer"
      , FormatTest -> Maybe Int
    formatTestInt32 :: !(Maybe Int) -- ^ "int32"
      , FormatTest -> Maybe Integer
    formatTestInt64 :: !(Maybe Integer) -- ^ "int64"
      , FormatTest -> Double
    formatTestNumber :: !(Double) -- ^ /Required/ "number"
      , FormatTest -> Maybe Float
    formatTestFloat :: !(Maybe Float) -- ^ "float"
      , FormatTest -> Maybe Double
    formatTestDouble :: !(Maybe Double) -- ^ "double"
      , FormatTest -> Maybe Text
    formatTestString :: !(Maybe Text) -- ^ "string"
      , FormatTest -> ByteArray
    formatTestByte :: !(ByteArray) -- ^ /Required/ "byte"
      , FormatTest -> Maybe [Char]
    formatTestBinary :: !(Maybe FilePath) -- ^ "binary"
      , FormatTest -> Date
    formatTestDate :: !(Date) -- ^ /Required/ "date"
      , FormatTest -> Maybe DateTime
    formatTestDateTime :: !(Maybe DateTime) -- ^ "dateTime"
      , FormatTest -> Maybe Text
    formatTestUuid :: !(Maybe Text) -- ^ "uuid"
      , FormatTest -> Text
    formatTestPassword :: !(Text) -- ^ /Required/ "password"
      , FormatTest -> Maybe Double
    formatTestBigDecimal :: !(Maybe Double) -- ^ "BigDecimal"
      } deriving (Int -> FormatTest -> ShowS
    [FormatTest] -> ShowS
    FormatTest -> [Char]
    (Int -> FormatTest -> ShowS)
    -> (FormatTest -> [Char])
    -> ([FormatTest] -> ShowS)
    -> Show FormatTest
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FormatTest -> ShowS
    showsPrec :: Int -> FormatTest -> ShowS
    $cshow :: FormatTest -> [Char]
    show :: FormatTest -> [Char]
    $cshowList :: [FormatTest] -> ShowS
    showList :: [FormatTest] -> ShowS
    P.Show, FormatTest -> FormatTest -> Bool
    (FormatTest -> FormatTest -> Bool)
    -> (FormatTest -> FormatTest -> Bool) -> Eq FormatTest
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FormatTest -> FormatTest -> Bool
    == :: FormatTest -> FormatTest -> Bool
    $c/= :: FormatTest -> FormatTest -> Bool
    /= :: FormatTest -> FormatTest -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON FormatTest
    instance A.FromJSON FormatTest where
      parseJSON :: Value -> Parser FormatTest
    parseJSON = [Char]
    -> (Object -> Parser FormatTest) -> Value -> Parser FormatTest
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "FormatTest" ((Object -> Parser FormatTest) -> Value -> Parser FormatTest)
    -> (Object -> Parser FormatTest) -> Value -> Parser FormatTest
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Int
    -> Maybe Int
    -> Maybe Integer
    -> Double
    -> Maybe Float
    -> Maybe Double
    -> Maybe Text
    -> ByteArray
    -> Maybe [Char]
    -> Date
    -> Maybe DateTime
    -> Maybe Text
    -> Text
    -> Maybe Double
    -> FormatTest
    FormatTest
          (Maybe Int
     -> Maybe Int
     -> Maybe Integer
     -> Double
     -> Maybe Float
     -> Maybe Double
     -> Maybe Text
     -> ByteArray
     -> Maybe [Char]
     -> Date
     -> Maybe DateTime
     -> Maybe Text
     -> Text
     -> Maybe Double
     -> FormatTest)
    -> Parser (Maybe Int)
    -> Parser
         (Maybe Int
          -> Maybe Integer
          -> Double
          -> Maybe Float
          -> Maybe Double
          -> Maybe Text
          -> ByteArray
          -> Maybe [Char]
          -> Date
          -> Maybe DateTime
          -> Maybe Text
          -> Text
          -> Maybe Double
          -> FormatTest)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "integer")
          Parser
      (Maybe Int
       -> Maybe Integer
       -> Double
       -> Maybe Float
       -> Maybe Double
       -> Maybe Text
       -> ByteArray
       -> Maybe [Char]
       -> Date
       -> Maybe DateTime
       -> Maybe Text
       -> Text
       -> Maybe Double
       -> FormatTest)
    -> Parser (Maybe Int)
    -> Parser
         (Maybe Integer
          -> Double
          -> Maybe Float
          -> Maybe Double
          -> Maybe Text
          -> ByteArray
          -> Maybe [Char]
          -> Date
          -> Maybe DateTime
          -> Maybe Text
          -> Text
          -> Maybe Double
          -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "int32")
          Parser
      (Maybe Integer
       -> Double
       -> Maybe Float
       -> Maybe Double
       -> Maybe Text
       -> ByteArray
       -> Maybe [Char]
       -> Date
       -> Maybe DateTime
       -> Maybe Text
       -> Text
       -> Maybe Double
       -> FormatTest)
    -> Parser (Maybe Integer)
    -> Parser
         (Double
          -> Maybe Float
          -> Maybe Double
          -> Maybe Text
          -> ByteArray
          -> Maybe [Char]
          -> Date
          -> Maybe DateTime
          -> Maybe Text
          -> Text
          -> Maybe Double
          -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Integer)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "int64")
          Parser
      (Double
       -> Maybe Float
       -> Maybe Double
       -> Maybe Text
       -> ByteArray
       -> Maybe [Char]
       -> Date
       -> Maybe DateTime
       -> Maybe Text
       -> Text
       -> Maybe Double
       -> FormatTest)
    -> Parser Double
    -> Parser
         (Maybe Float
          -> Maybe Double
          -> Maybe Text
          -> ByteArray
          -> Maybe [Char]
          -> Date
          -> Maybe DateTime
          -> Maybe Text
          -> Text
          -> Maybe Double
          -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Double
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "number")
          Parser
      (Maybe Float
       -> Maybe Double
       -> Maybe Text
       -> ByteArray
       -> Maybe [Char]
       -> Date
       -> Maybe DateTime
       -> Maybe Text
       -> Text
       -> Maybe Double
       -> FormatTest)
    -> Parser (Maybe Float)
    -> Parser
         (Maybe Double
          -> Maybe Text
          -> ByteArray
          -> Maybe [Char]
          -> Date
          -> Maybe DateTime
          -> Maybe Text
          -> Text
          -> Maybe Double
          -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Float)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "float")
          Parser
      (Maybe Double
       -> Maybe Text
       -> ByteArray
       -> Maybe [Char]
       -> Date
       -> Maybe DateTime
       -> Maybe Text
       -> Text
       -> Maybe Double
       -> FormatTest)
    -> Parser (Maybe Double)
    -> Parser
         (Maybe Text
          -> ByteArray
          -> Maybe [Char]
          -> Date
          -> Maybe DateTime
          -> Maybe Text
          -> Text
          -> Maybe Double
          -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Double)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "double")
          Parser
      (Maybe Text
       -> ByteArray
       -> Maybe [Char]
       -> Date
       -> Maybe DateTime
       -> Maybe Text
       -> Text
       -> Maybe Double
       -> FormatTest)
    -> Parser (Maybe Text)
    -> Parser
         (ByteArray
          -> Maybe [Char]
          -> Date
          -> Maybe DateTime
          -> Maybe Text
          -> Text
          -> Maybe Double
          -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "string")
          Parser
      (ByteArray
       -> Maybe [Char]
       -> Date
       -> Maybe DateTime
       -> Maybe Text
       -> Text
       -> Maybe Double
       -> FormatTest)
    -> Parser ByteArray
    -> Parser
         (Maybe [Char]
          -> Date
          -> Maybe DateTime
          -> Maybe Text
          -> Text
          -> Maybe Double
          -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser ByteArray
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "byte")
          Parser
      (Maybe [Char]
       -> Date
       -> Maybe DateTime
       -> Maybe Text
       -> Text
       -> Maybe Double
       -> FormatTest)
    -> Parser (Maybe [Char])
    -> Parser
         (Date
          -> Maybe DateTime
          -> Maybe Text
          -> Text
          -> Maybe Double
          -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Char])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "binary")
          Parser
      (Date
       -> Maybe DateTime
       -> Maybe Text
       -> Text
       -> Maybe Double
       -> FormatTest)
    -> Parser Date
    -> Parser
         (Maybe DateTime
          -> Maybe Text -> Text -> Maybe Double -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Date
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "date")
          Parser
      (Maybe DateTime
       -> Maybe Text -> Text -> Maybe Double -> FormatTest)
    -> Parser (Maybe DateTime)
    -> Parser (Maybe Text -> Text -> Maybe Double -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe DateTime)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "dateTime")
          Parser (Maybe Text -> Text -> Maybe Double -> FormatTest)
    -> Parser (Maybe Text)
    -> Parser (Text -> Maybe Double -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "uuid")
          Parser (Text -> Maybe Double -> FormatTest)
    -> Parser Text -> Parser (Maybe Double -> FormatTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Text
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "password")
          Parser (Maybe Double -> FormatTest)
    -> Parser (Maybe Double) -> Parser FormatTest
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Double)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "BigDecimal")

    -- | ToJSON FormatTest
    instance A.ToJSON FormatTest where
      toJSON :: FormatTest -> Value
    toJSON FormatTest {Double
    Maybe Double
    Maybe Float
    Maybe Int
    Maybe Integer
    Maybe [Char]
    Maybe Text
    Maybe DateTime
    Text
    ByteArray
    Date
    formatTestInteger :: FormatTest -> Maybe Int
    formatTestInt32 :: FormatTest -> Maybe Int
    formatTestInt64 :: FormatTest -> Maybe Integer
    formatTestNumber :: FormatTest -> Double
    formatTestFloat :: FormatTest -> Maybe Float
    formatTestDouble :: FormatTest -> Maybe Double
    formatTestString :: FormatTest -> Maybe Text
    formatTestByte :: FormatTest -> ByteArray
    formatTestBinary :: FormatTest -> Maybe [Char]
    formatTestDate :: FormatTest -> Date
    formatTestDateTime :: FormatTest -> Maybe DateTime
    formatTestUuid :: FormatTest -> Maybe Text
    formatTestPassword :: FormatTest -> Text
    formatTestBigDecimal :: FormatTest -> Maybe Double
    formatTestInteger :: Maybe Int
    formatTestInt32 :: Maybe Int
    formatTestInt64 :: Maybe Integer
    formatTestNumber :: Double
    formatTestFloat :: Maybe Float
    formatTestDouble :: Maybe Double
    formatTestString :: Maybe Text
    formatTestByte :: ByteArray
    formatTestBinary :: Maybe [Char]
    formatTestDate :: Date
    formatTestDateTime :: Maybe DateTime
    formatTestUuid :: Maybe Text
    formatTestPassword :: Text
    formatTestBigDecimal :: Maybe Double
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "integer" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    formatTestInteger
          , Key
    "int32" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    formatTestInt32
          , Key
    "int64" Key -> Maybe Integer -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Integer
    formatTestInt64
          , Key
    "number" Key -> Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Double
    formatTestNumber
          , Key
    "float" Key -> Maybe Float -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Float
    formatTestFloat
          , Key
    "double" Key -> Maybe Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Double
    formatTestDouble
          , Key
    "string" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    formatTestString
          , Key
    "byte" Key -> ByteArray -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= ByteArray
    formatTestByte
          , Key
    "binary" Key -> Maybe [Char] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Char]
    formatTestBinary
          , Key
    "date" Key -> Date -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Date
    formatTestDate
          , Key
    "dateTime" Key -> Maybe DateTime -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe DateTime
    formatTestDateTime
          , Key
    "uuid" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    formatTestUuid
          , Key
    "password" Key -> Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Text
    formatTestPassword
          , Key
    "BigDecimal" Key -> Maybe Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Double
    formatTestBigDecimal
          ]

    -- | Construct a value of type 'FormatTest' (by applying it's required fields, if any)
    mkFormatTest
      :: Double -- ^ 'formatTestNumber'
      -> ByteArray -- ^ 'formatTestByte'
      -> Date -- ^ 'formatTestDate'
      -> Text -- ^ 'formatTestPassword'
      -> FormatTest
    mkFormatTest :: Double -> ByteArray -> Date -> Text -> FormatTest
    mkFormatTest Double
    formatTestNumber ByteArray
    formatTestByte Date
    formatTestDate Text
    formatTestPassword =
      FormatTest
      { formatTestInteger :: Maybe Int
    formatTestInteger = Maybe Int
    forall a. Maybe a
    Nothing
      , formatTestInt32 :: Maybe Int
    formatTestInt32 = Maybe Int
    forall a. Maybe a
    Nothing
      , formatTestInt64 :: Maybe Integer
    formatTestInt64 = Maybe Integer
    forall a. Maybe a
    Nothing
      , Double
    formatTestNumber :: Double
    formatTestNumber :: Double
    formatTestNumber
      , formatTestFloat :: Maybe Float
    formatTestFloat = Maybe Float
    forall a. Maybe a
    Nothing
      , formatTestDouble :: Maybe Double
    formatTestDouble = Maybe Double
    forall a. Maybe a
    Nothing
      , formatTestString :: Maybe Text
    formatTestString = Maybe Text
    forall a. Maybe a
    Nothing
      , ByteArray
    formatTestByte :: ByteArray
    formatTestByte :: ByteArray
    formatTestByte
      , formatTestBinary :: Maybe [Char]
    formatTestBinary = Maybe [Char]
    forall a. Maybe a
    Nothing
      , Date
    formatTestDate :: Date
    formatTestDate :: Date
    formatTestDate
      , formatTestDateTime :: Maybe DateTime
    formatTestDateTime = Maybe DateTime
    forall a. Maybe a
    Nothing
      , formatTestUuid :: Maybe Text
    formatTestUuid = Maybe Text
    forall a. Maybe a
    Nothing
      , Text
    formatTestPassword :: Text
    formatTestPassword :: Text
    formatTestPassword
      , formatTestBigDecimal :: Maybe Double
    formatTestBigDecimal = Maybe Double
    forall a. Maybe a
    Nothing
      }

    -- ** HasOnlyReadOnly
    -- | HasOnlyReadOnly
    data HasOnlyReadOnly = HasOnlyReadOnly
      { HasOnlyReadOnly -> Maybe Text
    hasOnlyReadOnlyBar :: !(Maybe Text) -- ^ /ReadOnly/ "bar"
      , HasOnlyReadOnly -> Maybe Text
    hasOnlyReadOnlyFoo :: !(Maybe Text) -- ^ /ReadOnly/ "foo"
      } deriving (Int -> HasOnlyReadOnly -> ShowS
    [HasOnlyReadOnly] -> ShowS
    HasOnlyReadOnly -> [Char]
    (Int -> HasOnlyReadOnly -> ShowS)
    -> (HasOnlyReadOnly -> [Char])
    -> ([HasOnlyReadOnly] -> ShowS)
    -> Show HasOnlyReadOnly
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HasOnlyReadOnly -> ShowS
    showsPrec :: Int -> HasOnlyReadOnly -> ShowS
    $cshow :: HasOnlyReadOnly -> [Char]
    show :: HasOnlyReadOnly -> [Char]
    $cshowList :: [HasOnlyReadOnly] -> ShowS
    showList :: [HasOnlyReadOnly] -> ShowS
    P.Show, HasOnlyReadOnly -> HasOnlyReadOnly -> Bool
    (HasOnlyReadOnly -> HasOnlyReadOnly -> Bool)
    -> (HasOnlyReadOnly -> HasOnlyReadOnly -> Bool)
    -> Eq HasOnlyReadOnly
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HasOnlyReadOnly -> HasOnlyReadOnly -> Bool
    == :: HasOnlyReadOnly -> HasOnlyReadOnly -> Bool
    $c/= :: HasOnlyReadOnly -> HasOnlyReadOnly -> Bool
    /= :: HasOnlyReadOnly -> HasOnlyReadOnly -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON HasOnlyReadOnly
    instance A.FromJSON HasOnlyReadOnly where
      parseJSON :: Value -> Parser HasOnlyReadOnly
    parseJSON = [Char]
    -> (Object -> Parser HasOnlyReadOnly)
    -> Value
    -> Parser HasOnlyReadOnly
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "HasOnlyReadOnly" ((Object -> Parser HasOnlyReadOnly)
     -> Value -> Parser HasOnlyReadOnly)
    -> (Object -> Parser HasOnlyReadOnly)
    -> Value
    -> Parser HasOnlyReadOnly
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> Maybe Text -> HasOnlyReadOnly
    HasOnlyReadOnly
          (Maybe Text -> Maybe Text -> HasOnlyReadOnly)
    -> Parser (Maybe Text) -> Parser (Maybe Text -> HasOnlyReadOnly)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "bar")
          Parser (Maybe Text -> HasOnlyReadOnly)
    -> Parser (Maybe Text) -> Parser HasOnlyReadOnly
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "foo")

    -- | ToJSON HasOnlyReadOnly
    instance A.ToJSON HasOnlyReadOnly where
      toJSON :: HasOnlyReadOnly -> Value
    toJSON HasOnlyReadOnly {Maybe Text
    hasOnlyReadOnlyBar :: HasOnlyReadOnly -> Maybe Text
    hasOnlyReadOnlyFoo :: HasOnlyReadOnly -> Maybe Text
    hasOnlyReadOnlyBar :: Maybe Text
    hasOnlyReadOnlyFoo :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "bar" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    hasOnlyReadOnlyBar
          , Key
    "foo" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    hasOnlyReadOnlyFoo
          ]

    -- | Construct a value of type 'HasOnlyReadOnly' (by applying it's required fields, if any)
    mkHasOnlyReadOnly
      :: HasOnlyReadOnly
    mkHasOnlyReadOnly :: HasOnlyReadOnly
    mkHasOnlyReadOnly =
      HasOnlyReadOnly
      { hasOnlyReadOnlyBar :: Maybe Text
    hasOnlyReadOnlyBar = Maybe Text
    forall a. Maybe a
    Nothing
      , hasOnlyReadOnlyFoo :: Maybe Text
    hasOnlyReadOnlyFoo = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** MapTest
    -- | MapTest
    data MapTest = MapTest
      { MapTest -> Maybe (Map [Char] (Map [Char] Text))
    mapTestMapMapOfString :: !(Maybe (Map.Map String (Map.Map String Text))) -- ^ "map_map_of_string"
      , MapTest -> Maybe (Map [Char] E'Inner)
    mapTestMapOfEnumString :: !(Maybe (Map.Map String E'Inner)) -- ^ "map_of_enum_string"
      , MapTest -> Maybe (Map [Char] Bool)
    mapTestDirectMap :: !(Maybe (Map.Map String Bool)) -- ^ "direct_map"
      , MapTest -> Maybe (Map [Char] Bool)
    mapTestIndirectMap :: !(Maybe (Map.Map String Bool)) -- ^ "indirect_map"
      } deriving (Int -> MapTest -> ShowS
    [MapTest] -> ShowS
    MapTest -> [Char]
    (Int -> MapTest -> ShowS)
    -> (MapTest -> [Char]) -> ([MapTest] -> ShowS) -> Show MapTest
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MapTest -> ShowS
    showsPrec :: Int -> MapTest -> ShowS
    $cshow :: MapTest -> [Char]
    show :: MapTest -> [Char]
    $cshowList :: [MapTest] -> ShowS
    showList :: [MapTest] -> ShowS
    P.Show, MapTest -> MapTest -> Bool
    (MapTest -> MapTest -> Bool)
    -> (MapTest -> MapTest -> Bool) -> Eq MapTest
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MapTest -> MapTest -> Bool
    == :: MapTest -> MapTest -> Bool
    $c/= :: MapTest -> MapTest -> Bool
    /= :: MapTest -> MapTest -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON MapTest
    instance A.FromJSON MapTest where
      parseJSON :: Value -> Parser MapTest
    parseJSON = [Char] -> (Object -> Parser MapTest) -> Value -> Parser MapTest
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "MapTest" ((Object -> Parser MapTest) -> Value -> Parser MapTest)
    -> (Object -> Parser MapTest) -> Value -> Parser MapTest
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe (Map [Char] (Map [Char] Text))
    -> Maybe (Map [Char] E'Inner)
    -> Maybe (Map [Char] Bool)
    -> Maybe (Map [Char] Bool)
    -> MapTest
    MapTest
          (Maybe (Map [Char] (Map [Char] Text))
     -> Maybe (Map [Char] E'Inner)
     -> Maybe (Map [Char] Bool)
     -> Maybe (Map [Char] Bool)
     -> MapTest)
    -> Parser (Maybe (Map [Char] (Map [Char] Text)))
    -> Parser
         (Maybe (Map [Char] E'Inner)
          -> Maybe (Map [Char] Bool) -> Maybe (Map [Char] Bool) -> MapTest)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] (Map [Char] Text)))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_map_of_string")
          Parser
      (Maybe (Map [Char] E'Inner)
       -> Maybe (Map [Char] Bool) -> Maybe (Map [Char] Bool) -> MapTest)
    -> Parser (Maybe (Map [Char] E'Inner))
    -> Parser
         (Maybe (Map [Char] Bool) -> Maybe (Map [Char] Bool) -> MapTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] E'Inner))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map_of_enum_string")
          Parser
      (Maybe (Map [Char] Bool) -> Maybe (Map [Char] Bool) -> MapTest)
    -> Parser (Maybe (Map [Char] Bool))
    -> Parser (Maybe (Map [Char] Bool) -> MapTest)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] Bool))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "direct_map")
          Parser (Maybe (Map [Char] Bool) -> MapTest)
    -> Parser (Maybe (Map [Char] Bool)) -> Parser MapTest
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] Bool))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "indirect_map")

    -- | ToJSON MapTest
    instance A.ToJSON MapTest where
      toJSON :: MapTest -> Value
    toJSON MapTest {Maybe (Map [Char] Bool)
    Maybe (Map [Char] (Map [Char] Text))
    Maybe (Map [Char] E'Inner)
    mapTestMapMapOfString :: MapTest -> Maybe (Map [Char] (Map [Char] Text))
    mapTestMapOfEnumString :: MapTest -> Maybe (Map [Char] E'Inner)
    mapTestDirectMap :: MapTest -> Maybe (Map [Char] Bool)
    mapTestIndirectMap :: MapTest -> Maybe (Map [Char] Bool)
    mapTestMapMapOfString :: Maybe (Map [Char] (Map [Char] Text))
    mapTestMapOfEnumString :: Maybe (Map [Char] E'Inner)
    mapTestDirectMap :: Maybe (Map [Char] Bool)
    mapTestIndirectMap :: Maybe (Map [Char] Bool)
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "map_map_of_string" Key -> Maybe (Map [Char] (Map [Char] Text)) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] (Map [Char] Text))
    mapTestMapMapOfString
          , Key
    "map_of_enum_string" Key -> Maybe (Map [Char] E'Inner) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] E'Inner)
    mapTestMapOfEnumString
          , Key
    "direct_map" Key -> Maybe (Map [Char] Bool) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] Bool)
    mapTestDirectMap
          , Key
    "indirect_map" Key -> Maybe (Map [Char] Bool) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] Bool)
    mapTestIndirectMap
          ]

    -- | Construct a value of type 'MapTest' (by applying it's required fields, if any)
    mkMapTest
      :: MapTest
    mkMapTest :: MapTest
    mkMapTest =
      MapTest
      { mapTestMapMapOfString :: Maybe (Map [Char] (Map [Char] Text))
    mapTestMapMapOfString = Maybe (Map [Char] (Map [Char] Text))
    forall a. Maybe a
    Nothing
      , mapTestMapOfEnumString :: Maybe (Map [Char] E'Inner)
    mapTestMapOfEnumString = Maybe (Map [Char] E'Inner)
    forall a. Maybe a
    Nothing
      , mapTestDirectMap :: Maybe (Map [Char] Bool)
    mapTestDirectMap = Maybe (Map [Char] Bool)
    forall a. Maybe a
    Nothing
      , mapTestIndirectMap :: Maybe (Map [Char] Bool)
    mapTestIndirectMap = Maybe (Map [Char] Bool)
    forall a. Maybe a
    Nothing
      }

    -- ** MixedPropertiesAndAdditionalPropertiesClass
    -- | MixedPropertiesAndAdditionalPropertiesClass
    data MixedPropertiesAndAdditionalPropertiesClass = MixedPropertiesAndAdditionalPropertiesClass
      { MixedPropertiesAndAdditionalPropertiesClass -> Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid :: !(Maybe Text) -- ^ "uuid"
      , MixedPropertiesAndAdditionalPropertiesClass -> Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: !(Maybe DateTime) -- ^ "dateTime"
      , MixedPropertiesAndAdditionalPropertiesClass
    -> Maybe (Map [Char] Animal)
    mixedPropertiesAndAdditionalPropertiesClassMap :: !(Maybe (Map.Map String Animal)) -- ^ "map"
      } deriving (Int -> MixedPropertiesAndAdditionalPropertiesClass -> ShowS
    [MixedPropertiesAndAdditionalPropertiesClass] -> ShowS
    MixedPropertiesAndAdditionalPropertiesClass -> [Char]
    (Int -> MixedPropertiesAndAdditionalPropertiesClass -> ShowS)
    -> (MixedPropertiesAndAdditionalPropertiesClass -> [Char])
    -> ([MixedPropertiesAndAdditionalPropertiesClass] -> ShowS)
    -> Show MixedPropertiesAndAdditionalPropertiesClass
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MixedPropertiesAndAdditionalPropertiesClass -> ShowS
    showsPrec :: Int -> MixedPropertiesAndAdditionalPropertiesClass -> ShowS
    $cshow :: MixedPropertiesAndAdditionalPropertiesClass -> [Char]
    show :: MixedPropertiesAndAdditionalPropertiesClass -> [Char]
    $cshowList :: [MixedPropertiesAndAdditionalPropertiesClass] -> ShowS
    showList :: [MixedPropertiesAndAdditionalPropertiesClass] -> ShowS
    P.Show, MixedPropertiesAndAdditionalPropertiesClass
    -> MixedPropertiesAndAdditionalPropertiesClass -> Bool
    (MixedPropertiesAndAdditionalPropertiesClass
     -> MixedPropertiesAndAdditionalPropertiesClass -> Bool)
    -> (MixedPropertiesAndAdditionalPropertiesClass
        -> MixedPropertiesAndAdditionalPropertiesClass -> Bool)
    -> Eq MixedPropertiesAndAdditionalPropertiesClass
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MixedPropertiesAndAdditionalPropertiesClass
    -> MixedPropertiesAndAdditionalPropertiesClass -> Bool
    == :: MixedPropertiesAndAdditionalPropertiesClass
    -> MixedPropertiesAndAdditionalPropertiesClass -> Bool
    $c/= :: MixedPropertiesAndAdditionalPropertiesClass
    -> MixedPropertiesAndAdditionalPropertiesClass -> Bool
    /= :: MixedPropertiesAndAdditionalPropertiesClass
    -> MixedPropertiesAndAdditionalPropertiesClass -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON MixedPropertiesAndAdditionalPropertiesClass
    instance A.FromJSON MixedPropertiesAndAdditionalPropertiesClass where
      parseJSON :: Value -> Parser MixedPropertiesAndAdditionalPropertiesClass
    parseJSON = [Char]
    -> (Object -> Parser MixedPropertiesAndAdditionalPropertiesClass)
    -> Value
    -> Parser MixedPropertiesAndAdditionalPropertiesClass
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "MixedPropertiesAndAdditionalPropertiesClass" ((Object -> Parser MixedPropertiesAndAdditionalPropertiesClass)
     -> Value -> Parser MixedPropertiesAndAdditionalPropertiesClass)
    -> (Object -> Parser MixedPropertiesAndAdditionalPropertiesClass)
    -> Value
    -> Parser MixedPropertiesAndAdditionalPropertiesClass
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text
    -> Maybe DateTime
    -> Maybe (Map [Char] Animal)
    -> MixedPropertiesAndAdditionalPropertiesClass
    MixedPropertiesAndAdditionalPropertiesClass
          (Maybe Text
     -> Maybe DateTime
     -> Maybe (Map [Char] Animal)
     -> MixedPropertiesAndAdditionalPropertiesClass)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe DateTime
          -> Maybe (Map [Char] Animal)
          -> MixedPropertiesAndAdditionalPropertiesClass)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "uuid")
          Parser
      (Maybe DateTime
       -> Maybe (Map [Char] Animal)
       -> MixedPropertiesAndAdditionalPropertiesClass)
    -> Parser (Maybe DateTime)
    -> Parser
         (Maybe (Map [Char] Animal)
          -> MixedPropertiesAndAdditionalPropertiesClass)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe DateTime)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "dateTime")
          Parser
      (Maybe (Map [Char] Animal)
       -> MixedPropertiesAndAdditionalPropertiesClass)
    -> Parser (Maybe (Map [Char] Animal))
    -> Parser MixedPropertiesAndAdditionalPropertiesClass
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe (Map [Char] Animal))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "map")

    -- | ToJSON MixedPropertiesAndAdditionalPropertiesClass
    instance A.ToJSON MixedPropertiesAndAdditionalPropertiesClass where
      toJSON :: MixedPropertiesAndAdditionalPropertiesClass -> Value
    toJSON MixedPropertiesAndAdditionalPropertiesClass {Maybe (Map [Char] Animal)
    Maybe Text
    Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassUuid :: MixedPropertiesAndAdditionalPropertiesClass -> Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: MixedPropertiesAndAdditionalPropertiesClass -> Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: MixedPropertiesAndAdditionalPropertiesClass
    -> Maybe (Map [Char] Animal)
    mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map [Char] Animal)
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "uuid" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid
          , Key
    "dateTime" Key -> Maybe DateTime -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassDateTime
          , Key
    "map" Key -> Maybe (Map [Char] Animal) -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe (Map [Char] Animal)
    mixedPropertiesAndAdditionalPropertiesClassMap
          ]

    -- | Construct a value of type 'MixedPropertiesAndAdditionalPropertiesClass' (by applying it's required fields, if any)
    mkMixedPropertiesAndAdditionalPropertiesClass
      :: MixedPropertiesAndAdditionalPropertiesClass
    mkMixedPropertiesAndAdditionalPropertiesClass :: MixedPropertiesAndAdditionalPropertiesClass
    mkMixedPropertiesAndAdditionalPropertiesClass =
      MixedPropertiesAndAdditionalPropertiesClass
      { mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
    mixedPropertiesAndAdditionalPropertiesClassUuid = Maybe Text
    forall a. Maybe a
    Nothing
      , mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
    mixedPropertiesAndAdditionalPropertiesClassDateTime = Maybe DateTime
    forall a. Maybe a
    Nothing
      , mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map [Char] Animal)
    mixedPropertiesAndAdditionalPropertiesClassMap = Maybe (Map [Char] Animal)
    forall a. Maybe a
    Nothing
      }

    -- ** Model200Response
    -- | Model200Response
    -- Model for testing model name starting with number
    data Model200Response = Model200Response
      { Model200Response -> Maybe Int
    model200ResponseName :: !(Maybe Int) -- ^ "name"
      , Model200Response -> Maybe Text
    model200ResponseClass :: !(Maybe Text) -- ^ "class"
      } deriving (Int -> Model200Response -> ShowS
    [Model200Response] -> ShowS
    Model200Response -> [Char]
    (Int -> Model200Response -> ShowS)
    -> (Model200Response -> [Char])
    -> ([Model200Response] -> ShowS)
    -> Show Model200Response
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Model200Response -> ShowS
    showsPrec :: Int -> Model200Response -> ShowS
    $cshow :: Model200Response -> [Char]
    show :: Model200Response -> [Char]
    $cshowList :: [Model200Response] -> ShowS
    showList :: [Model200Response] -> ShowS
    P.Show, Model200Response -> Model200Response -> Bool
    (Model200Response -> Model200Response -> Bool)
    -> (Model200Response -> Model200Response -> Bool)
    -> Eq Model200Response
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Model200Response -> Model200Response -> Bool
    == :: Model200Response -> Model200Response -> Bool
    $c/= :: Model200Response -> Model200Response -> Bool
    /= :: Model200Response -> Model200Response -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Model200Response
    instance A.FromJSON Model200Response where
      parseJSON :: Value -> Parser Model200Response
    parseJSON = [Char]
    -> (Object -> Parser Model200Response)
    -> Value
    -> Parser Model200Response
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Model200Response" ((Object -> Parser Model200Response)
     -> Value -> Parser Model200Response)
    -> (Object -> Parser Model200Response)
    -> Value
    -> Parser Model200Response
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Int -> Maybe Text -> Model200Response
    Model200Response
          (Maybe Int -> Maybe Text -> Model200Response)
    -> Parser (Maybe Int) -> Parser (Maybe Text -> Model200Response)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name")
          Parser (Maybe Text -> Model200Response)
    -> Parser (Maybe Text) -> Parser Model200Response
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "class")

    -- | ToJSON Model200Response
    instance A.ToJSON Model200Response where
      toJSON :: Model200Response -> Value
    toJSON Model200Response {Maybe Int
    Maybe Text
    model200ResponseName :: Model200Response -> Maybe Int
    model200ResponseClass :: Model200Response -> Maybe Text
    model200ResponseName :: Maybe Int
    model200ResponseClass :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "name" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    model200ResponseName
          , Key
    "class" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    model200ResponseClass
          ]

    -- | Construct a value of type 'Model200Response' (by applying it's required fields, if any)
    mkModel200Response
      :: Model200Response
    mkModel200Response :: Model200Response
    mkModel200Response =
      Model200Response
      { model200ResponseName :: Maybe Int
    model200ResponseName = Maybe Int
    forall a. Maybe a
    Nothing
      , model200ResponseClass :: Maybe Text
    model200ResponseClass = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** ModelList
    -- | ModelList
    data ModelList = ModelList
      { ModelList -> Maybe Text
    modelList123list :: !(Maybe Text) -- ^ "123-list"
      } deriving (Int -> ModelList -> ShowS
    [ModelList] -> ShowS
    ModelList -> [Char]
    (Int -> ModelList -> ShowS)
    -> (ModelList -> [Char])
    -> ([ModelList] -> ShowS)
    -> Show ModelList
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ModelList -> ShowS
    showsPrec :: Int -> ModelList -> ShowS
    $cshow :: ModelList -> [Char]
    show :: ModelList -> [Char]
    $cshowList :: [ModelList] -> ShowS
    showList :: [ModelList] -> ShowS
    P.Show, ModelList -> ModelList -> Bool
    (ModelList -> ModelList -> Bool)
    -> (ModelList -> ModelList -> Bool) -> Eq ModelList
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ModelList -> ModelList -> Bool
    == :: ModelList -> ModelList -> Bool
    $c/= :: ModelList -> ModelList -> Bool
    /= :: ModelList -> ModelList -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON ModelList
    instance A.FromJSON ModelList where
      parseJSON :: Value -> Parser ModelList
    parseJSON = [Char] -> (Object -> Parser ModelList) -> Value -> Parser ModelList
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "ModelList" ((Object -> Parser ModelList) -> Value -> Parser ModelList)
    -> (Object -> Parser ModelList) -> Value -> Parser ModelList
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> ModelList
    ModelList
          (Maybe Text -> ModelList)
    -> Parser (Maybe Text) -> Parser ModelList
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "123-list")

    -- | ToJSON ModelList
    instance A.ToJSON ModelList where
      toJSON :: ModelList -> Value
    toJSON ModelList {Maybe Text
    modelList123list :: ModelList -> Maybe Text
    modelList123list :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "123-list" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    modelList123list
          ]

    -- | Construct a value of type 'ModelList' (by applying it's required fields, if any)
    mkModelList
      :: ModelList
    mkModelList :: ModelList
    mkModelList =
      ModelList
      { modelList123list :: Maybe Text
    modelList123list = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** ModelReturn
    -- | ModelReturn
    -- Model for testing reserved words
    data ModelReturn = ModelReturn
      { ModelReturn -> Maybe Int
    modelReturnReturn :: !(Maybe Int) -- ^ "return"
      } deriving (Int -> ModelReturn -> ShowS
    [ModelReturn] -> ShowS
    ModelReturn -> [Char]
    (Int -> ModelReturn -> ShowS)
    -> (ModelReturn -> [Char])
    -> ([ModelReturn] -> ShowS)
    -> Show ModelReturn
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ModelReturn -> ShowS
    showsPrec :: Int -> ModelReturn -> ShowS
    $cshow :: ModelReturn -> [Char]
    show :: ModelReturn -> [Char]
    $cshowList :: [ModelReturn] -> ShowS
    showList :: [ModelReturn] -> ShowS
    P.Show, ModelReturn -> ModelReturn -> Bool
    (ModelReturn -> ModelReturn -> Bool)
    -> (ModelReturn -> ModelReturn -> Bool) -> Eq ModelReturn
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ModelReturn -> ModelReturn -> Bool
    == :: ModelReturn -> ModelReturn -> Bool
    $c/= :: ModelReturn -> ModelReturn -> Bool
    /= :: ModelReturn -> ModelReturn -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON ModelReturn
    instance A.FromJSON ModelReturn where
      parseJSON :: Value -> Parser ModelReturn
    parseJSON = [Char]
    -> (Object -> Parser ModelReturn) -> Value -> Parser ModelReturn
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "ModelReturn" ((Object -> Parser ModelReturn) -> Value -> Parser ModelReturn)
    -> (Object -> Parser ModelReturn) -> Value -> Parser ModelReturn
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Int -> ModelReturn
    ModelReturn
          (Maybe Int -> ModelReturn)
    -> Parser (Maybe Int) -> Parser ModelReturn
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "return")

    -- | ToJSON ModelReturn
    instance A.ToJSON ModelReturn where
      toJSON :: ModelReturn -> Value
    toJSON ModelReturn {Maybe Int
    modelReturnReturn :: ModelReturn -> Maybe Int
    modelReturnReturn :: Maybe Int
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "return" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    modelReturnReturn
          ]

    -- | Construct a value of type 'ModelReturn' (by applying it's required fields, if any)
    mkModelReturn
      :: ModelReturn
    mkModelReturn :: ModelReturn
    mkModelReturn =
      ModelReturn
      { modelReturnReturn :: Maybe Int
    modelReturnReturn = Maybe Int
    forall a. Maybe a
    Nothing
      }

    -- ** Name
    -- | Name
    -- Model for testing model name same as property name
    data Name = Name
      { Name -> Int
    nameName :: !(Int) -- ^ /Required/ "name"
      , Name -> Maybe Int
    nameSnakeCase :: !(Maybe Int) -- ^ /ReadOnly/ "snake_case"
      , Name -> Maybe Text
    nameProperty :: !(Maybe Text) -- ^ "property"
      , Name -> Maybe Int
    name123number :: !(Maybe Int) -- ^ /ReadOnly/ "123Number"
      } deriving (Int -> Name -> ShowS
    [Name] -> ShowS
    Name -> [Char]
    (Int -> Name -> ShowS)
    -> (Name -> [Char]) -> ([Name] -> ShowS) -> Show Name
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Name -> ShowS
    showsPrec :: Int -> Name -> ShowS
    $cshow :: Name -> [Char]
    show :: Name -> [Char]
    $cshowList :: [Name] -> ShowS
    showList :: [Name] -> ShowS
    P.Show, Name -> Name -> Bool
    (Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Name -> Name -> Bool
    == :: Name -> Name -> Bool
    $c/= :: Name -> Name -> Bool
    /= :: Name -> Name -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Name
    instance A.FromJSON Name where
      parseJSON :: Value -> Parser Name
    parseJSON = [Char] -> (Object -> Parser Name) -> Value -> Parser Name
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Name" ((Object -> Parser Name) -> Value -> Parser Name)
    -> (Object -> Parser Name) -> Value -> Parser Name
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Int -> Maybe Int -> Maybe Text -> Maybe Int -> Name
    Name
          (Int -> Maybe Int -> Maybe Text -> Maybe Int -> Name)
    -> Parser Int
    -> Parser (Maybe Int -> Maybe Text -> Maybe Int -> Name)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser Int
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "name")
          Parser (Maybe Int -> Maybe Text -> Maybe Int -> Name)
    -> Parser (Maybe Int) -> Parser (Maybe Text -> Maybe Int -> Name)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "snake_case")
          Parser (Maybe Text -> Maybe Int -> Name)
    -> Parser (Maybe Text) -> Parser (Maybe Int -> Name)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "property")
          Parser (Maybe Int -> Name) -> Parser (Maybe Int) -> Parser Name
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "123Number")

    -- | ToJSON Name
    instance A.ToJSON Name where
      toJSON :: Name -> Value
    toJSON Name {Int
    Maybe Int
    Maybe Text
    nameName :: Name -> Int
    nameSnakeCase :: Name -> Maybe Int
    nameProperty :: Name -> Maybe Text
    name123number :: Name -> Maybe Int
    nameName :: Int
    nameSnakeCase :: Maybe Int
    nameProperty :: Maybe Text
    name123number :: Maybe Int
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "name" Key -> Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Int
    nameName
          , Key
    "snake_case" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    nameSnakeCase
          , Key
    "property" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    nameProperty
          , Key
    "123Number" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    name123number
          ]

    -- | Construct a value of type 'Name' (by applying it's required fields, if any)
    mkName
      :: Int -- ^ 'nameName'
      -> Name
    mkName :: Int -> Name
    mkName Int
    nameName =
      Name
      { Int
    nameName :: Int
    nameName :: Int
    nameName
      , nameSnakeCase :: Maybe Int
    nameSnakeCase = Maybe Int
    forall a. Maybe a
    Nothing
      , nameProperty :: Maybe Text
    nameProperty = Maybe Text
    forall a. Maybe a
    Nothing
      , name123number :: Maybe Int
    name123number = Maybe Int
    forall a. Maybe a
    Nothing
      }

    -- ** NumberOnly
    -- | NumberOnly
    data NumberOnly = NumberOnly
      { NumberOnly -> Maybe Double
    numberOnlyJustNumber :: !(Maybe Double) -- ^ "JustNumber"
      } deriving (Int -> NumberOnly -> ShowS
    [NumberOnly] -> ShowS
    NumberOnly -> [Char]
    (Int -> NumberOnly -> ShowS)
    -> (NumberOnly -> [Char])
    -> ([NumberOnly] -> ShowS)
    -> Show NumberOnly
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NumberOnly -> ShowS
    showsPrec :: Int -> NumberOnly -> ShowS
    $cshow :: NumberOnly -> [Char]
    show :: NumberOnly -> [Char]
    $cshowList :: [NumberOnly] -> ShowS
    showList :: [NumberOnly] -> ShowS
    P.Show, NumberOnly -> NumberOnly -> Bool
    (NumberOnly -> NumberOnly -> Bool)
    -> (NumberOnly -> NumberOnly -> Bool) -> Eq NumberOnly
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NumberOnly -> NumberOnly -> Bool
    == :: NumberOnly -> NumberOnly -> Bool
    $c/= :: NumberOnly -> NumberOnly -> Bool
    /= :: NumberOnly -> NumberOnly -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON NumberOnly
    instance A.FromJSON NumberOnly where
      parseJSON :: Value -> Parser NumberOnly
    parseJSON = [Char]
    -> (Object -> Parser NumberOnly) -> Value -> Parser NumberOnly
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "NumberOnly" ((Object -> Parser NumberOnly) -> Value -> Parser NumberOnly)
    -> (Object -> Parser NumberOnly) -> Value -> Parser NumberOnly
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Double -> NumberOnly
    NumberOnly
          (Maybe Double -> NumberOnly)
    -> Parser (Maybe Double) -> Parser NumberOnly
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Double)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "JustNumber")

    -- | ToJSON NumberOnly
    instance A.ToJSON NumberOnly where
      toJSON :: NumberOnly -> Value
    toJSON NumberOnly {Maybe Double
    numberOnlyJustNumber :: NumberOnly -> Maybe Double
    numberOnlyJustNumber :: Maybe Double
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "JustNumber" Key -> Maybe Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Double
    numberOnlyJustNumber
          ]

    -- | Construct a value of type 'NumberOnly' (by applying it's required fields, if any)
    mkNumberOnly
      :: NumberOnly
    mkNumberOnly :: NumberOnly
    mkNumberOnly =
      NumberOnly
      { numberOnlyJustNumber :: Maybe Double
    numberOnlyJustNumber = Maybe Double
    forall a. Maybe a
    Nothing
      }

    -- ** Order
    -- | Order
    data Order = Order
      { Order -> Maybe Integer
    orderId :: !(Maybe Integer) -- ^ "id"
      , Order -> Maybe Integer
    orderPetId :: !(Maybe Integer) -- ^ "petId"
      , Order -> Maybe Int
    orderQuantity :: !(Maybe Int) -- ^ "quantity"
      , Order -> Maybe DateTime
    orderShipDate :: !(Maybe DateTime) -- ^ "shipDate"
      , Order -> Maybe E'Status
    orderStatus :: !(Maybe E'Status) -- ^ "status" - Order Status
      , Order -> Maybe Bool
    orderComplete :: !(Maybe Bool) -- ^ "complete"
      } deriving (Int -> Order -> ShowS
    [Order] -> ShowS
    Order -> [Char]
    (Int -> Order -> ShowS)
    -> (Order -> [Char]) -> ([Order] -> ShowS) -> Show Order
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Order -> ShowS
    showsPrec :: Int -> Order -> ShowS
    $cshow :: Order -> [Char]
    show :: Order -> [Char]
    $cshowList :: [Order] -> ShowS
    showList :: [Order] -> ShowS
    P.Show, Order -> Order -> Bool
    (Order -> Order -> Bool) -> (Order -> Order -> Bool) -> Eq Order
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Order -> Order -> Bool
    == :: Order -> Order -> Bool
    $c/= :: Order -> Order -> Bool
    /= :: Order -> Order -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Order
    instance A.FromJSON Order where
      parseJSON :: Value -> Parser Order
    parseJSON = [Char] -> (Object -> Parser Order) -> Value -> Parser Order
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Order" ((Object -> Parser Order) -> Value -> Parser Order)
    -> (Object -> Parser Order) -> Value -> Parser Order
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Integer
    -> Maybe Integer
    -> Maybe Int
    -> Maybe DateTime
    -> Maybe E'Status
    -> Maybe Bool
    -> Order
    Order
          (Maybe Integer
     -> Maybe Integer
     -> Maybe Int
     -> Maybe DateTime
     -> Maybe E'Status
     -> Maybe Bool
     -> Order)
    -> Parser (Maybe Integer)
    -> Parser
         (Maybe Integer
          -> Maybe Int
          -> Maybe DateTime
          -> Maybe E'Status
          -> Maybe Bool
          -> Order)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Integer)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "id")
          Parser
      (Maybe Integer
       -> Maybe Int
       -> Maybe DateTime
       -> Maybe E'Status
       -> Maybe Bool
       -> Order)
    -> Parser (Maybe Integer)
    -> Parser
         (Maybe Int
          -> Maybe DateTime -> Maybe E'Status -> Maybe Bool -> Order)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Integer)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "petId")
          Parser
      (Maybe Int
       -> Maybe DateTime -> Maybe E'Status -> Maybe Bool -> Order)
    -> Parser (Maybe Int)
    -> Parser (Maybe DateTime -> Maybe E'Status -> Maybe Bool -> Order)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "quantity")
          Parser (Maybe DateTime -> Maybe E'Status -> Maybe Bool -> Order)
    -> Parser (Maybe DateTime)
    -> Parser (Maybe E'Status -> Maybe Bool -> Order)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe DateTime)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "shipDate")
          Parser (Maybe E'Status -> Maybe Bool -> Order)
    -> Parser (Maybe E'Status) -> Parser (Maybe Bool -> Order)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe E'Status)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "status")
          Parser (Maybe Bool -> Order) -> Parser (Maybe Bool) -> Parser Order
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Bool)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "complete")

    -- | ToJSON Order
    instance A.ToJSON Order where
      toJSON :: Order -> Value
    toJSON Order {Maybe Bool
    Maybe Int
    Maybe Integer
    Maybe DateTime
    Maybe E'Status
    orderId :: Order -> Maybe Integer
    orderPetId :: Order -> Maybe Integer
    orderQuantity :: Order -> Maybe Int
    orderShipDate :: Order -> Maybe DateTime
    orderStatus :: Order -> Maybe E'Status
    orderComplete :: Order -> Maybe Bool
    orderId :: Maybe Integer
    orderPetId :: Maybe Integer
    orderQuantity :: Maybe Int
    orderShipDate :: Maybe DateTime
    orderStatus :: Maybe E'Status
    orderComplete :: Maybe Bool
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "id" Key -> Maybe Integer -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Integer
    orderId
          , Key
    "petId" Key -> Maybe Integer -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Integer
    orderPetId
          , Key
    "quantity" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    orderQuantity
          , Key
    "shipDate" Key -> Maybe DateTime -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe DateTime
    orderShipDate
          , Key
    "status" Key -> Maybe E'Status -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe E'Status
    orderStatus
          , Key
    "complete" Key -> Maybe Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Bool
    orderComplete
          ]

    -- | Construct a value of type 'Order' (by applying it's required fields, if any)
    mkOrder
      :: Order
    mkOrder :: Order
    mkOrder =
      Order
      { orderId :: Maybe Integer
    orderId = Maybe Integer
    forall a. Maybe a
    Nothing
      , orderPetId :: Maybe Integer
    orderPetId = Maybe Integer
    forall a. Maybe a
    Nothing
      , orderQuantity :: Maybe Int
    orderQuantity = Maybe Int
    forall a. Maybe a
    Nothing
      , orderShipDate :: Maybe DateTime
    orderShipDate = Maybe DateTime
    forall a. Maybe a
    Nothing
      , orderStatus :: Maybe E'Status
    orderStatus = Maybe E'Status
    forall a. Maybe a
    Nothing
      , orderComplete :: Maybe Bool
    orderComplete = Maybe Bool
    forall a. Maybe a
    Nothing
      }

    -- ** OuterComposite
    -- | OuterComposite
    data OuterComposite = OuterComposite
      { OuterComposite -> Maybe Double
    outerCompositeMyNumber :: !(Maybe Double) -- ^ "my_number"
      , OuterComposite -> Maybe Text
    outerCompositeMyString :: !(Maybe Text) -- ^ "my_string"
      , OuterComposite -> Maybe Bool
    outerCompositeMyBoolean :: !(Maybe Bool) -- ^ "my_boolean"
      } deriving (Int -> OuterComposite -> ShowS
    [OuterComposite] -> ShowS
    OuterComposite -> [Char]
    (Int -> OuterComposite -> ShowS)
    -> (OuterComposite -> [Char])
    -> ([OuterComposite] -> ShowS)
    -> Show OuterComposite
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OuterComposite -> ShowS
    showsPrec :: Int -> OuterComposite -> ShowS
    $cshow :: OuterComposite -> [Char]
    show :: OuterComposite -> [Char]
    $cshowList :: [OuterComposite] -> ShowS
    showList :: [OuterComposite] -> ShowS
    P.Show, OuterComposite -> OuterComposite -> Bool
    (OuterComposite -> OuterComposite -> Bool)
    -> (OuterComposite -> OuterComposite -> Bool) -> Eq OuterComposite
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OuterComposite -> OuterComposite -> Bool
    == :: OuterComposite -> OuterComposite -> Bool
    $c/= :: OuterComposite -> OuterComposite -> Bool
    /= :: OuterComposite -> OuterComposite -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON OuterComposite
    instance A.FromJSON OuterComposite where
      parseJSON :: Value -> Parser OuterComposite
    parseJSON = [Char]
    -> (Object -> Parser OuterComposite)
    -> Value
    -> Parser OuterComposite
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "OuterComposite" ((Object -> Parser OuterComposite)
     -> Value -> Parser OuterComposite)
    -> (Object -> Parser OuterComposite)
    -> Value
    -> Parser OuterComposite
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Double -> Maybe Text -> Maybe Bool -> OuterComposite
    OuterComposite
          (Maybe Double -> Maybe Text -> Maybe Bool -> OuterComposite)
    -> Parser (Maybe Double)
    -> Parser (Maybe Text -> Maybe Bool -> OuterComposite)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Double)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "my_number")
          Parser (Maybe Text -> Maybe Bool -> OuterComposite)
    -> Parser (Maybe Text) -> Parser (Maybe Bool -> OuterComposite)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "my_string")
          Parser (Maybe Bool -> OuterComposite)
    -> Parser (Maybe Bool) -> Parser OuterComposite
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Bool)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "my_boolean")

    -- | ToJSON OuterComposite
    instance A.ToJSON OuterComposite where
      toJSON :: OuterComposite -> Value
    toJSON OuterComposite {Maybe Bool
    Maybe Double
    Maybe Text
    outerCompositeMyNumber :: OuterComposite -> Maybe Double
    outerCompositeMyString :: OuterComposite -> Maybe Text
    outerCompositeMyBoolean :: OuterComposite -> Maybe Bool
    outerCompositeMyNumber :: Maybe Double
    outerCompositeMyString :: Maybe Text
    outerCompositeMyBoolean :: Maybe Bool
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "my_number" Key -> Maybe Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Double
    outerCompositeMyNumber
          , Key
    "my_string" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    outerCompositeMyString
          , Key
    "my_boolean" Key -> Maybe Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Bool
    outerCompositeMyBoolean
          ]

    -- | Construct a value of type 'OuterComposite' (by applying it's required fields, if any)
    mkOuterComposite
      :: OuterComposite
    mkOuterComposite :: OuterComposite
    mkOuterComposite =
      OuterComposite
      { outerCompositeMyNumber :: Maybe Double
    outerCompositeMyNumber = Maybe Double
    forall a. Maybe a
    Nothing
      , outerCompositeMyString :: Maybe Text
    outerCompositeMyString = Maybe Text
    forall a. Maybe a
    Nothing
      , outerCompositeMyBoolean :: Maybe Bool
    outerCompositeMyBoolean = Maybe Bool
    forall a. Maybe a
    Nothing
      }

    -- ** Pet
    -- | Pet
    data Pet = Pet
      { Pet -> Maybe Integer
    petId :: !(Maybe Integer) -- ^ "id"
      , Pet -> Maybe Category
    petCategory :: !(Maybe Category) -- ^ "category"
      , Pet -> Text
    petName :: !(Text) -- ^ /Required/ "name"
      , Pet -> [Text]
    petPhotoUrls :: !([Text]) -- ^ /Required/ "photoUrls"
      , Pet -> Maybe [Tag]
    petTags :: !(Maybe [Tag]) -- ^ "tags"
      , Pet -> Maybe E'Status2
    petStatus :: !(Maybe E'Status2) -- ^ "status" - pet status in the store
      } deriving (Int -> Pet -> ShowS
    [Pet] -> ShowS
    Pet -> [Char]
    (Int -> Pet -> ShowS)
    -> (Pet -> [Char]) -> ([Pet] -> ShowS) -> Show Pet
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Pet -> ShowS
    showsPrec :: Int -> Pet -> ShowS
    $cshow :: Pet -> [Char]
    show :: Pet -> [Char]
    $cshowList :: [Pet] -> ShowS
    showList :: [Pet] -> ShowS
    P.Show, Pet -> Pet -> Bool
    (Pet -> Pet -> Bool) -> (Pet -> Pet -> Bool) -> Eq Pet
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Pet -> Pet -> Bool
    == :: Pet -> Pet -> Bool
    $c/= :: Pet -> Pet -> Bool
    /= :: Pet -> Pet -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Pet
    instance A.FromJSON Pet where
      parseJSON :: Value -> Parser Pet
    parseJSON = [Char] -> (Object -> Parser Pet) -> Value -> Parser Pet
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Pet" ((Object -> Parser Pet) -> Value -> Parser Pet)
    -> (Object -> Parser Pet) -> Value -> Parser Pet
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Integer
    -> Maybe Category
    -> Text
    -> [Text]
    -> Maybe [Tag]
    -> Maybe E'Status2
    -> Pet
    Pet
          (Maybe Integer
     -> Maybe Category
     -> Text
     -> [Text]
     -> Maybe [Tag]
     -> Maybe E'Status2
     -> Pet)
    -> Parser (Maybe Integer)
    -> Parser
         (Maybe Category
          -> Text -> [Text] -> Maybe [Tag] -> Maybe E'Status2 -> Pet)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Integer)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "id")
          Parser
      (Maybe Category
       -> Text -> [Text] -> Maybe [Tag] -> Maybe E'Status2 -> Pet)
    -> Parser (Maybe Category)
    -> Parser (Text -> [Text] -> Maybe [Tag] -> Maybe E'Status2 -> Pet)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Category)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "category")
          Parser (Text -> [Text] -> Maybe [Tag] -> Maybe E'Status2 -> Pet)
    -> Parser Text
    -> Parser ([Text] -> Maybe [Tag] -> Maybe E'Status2 -> Pet)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Text
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "name")
          Parser ([Text] -> Maybe [Tag] -> Maybe E'Status2 -> Pet)
    -> Parser [Text] -> Parser (Maybe [Tag] -> Maybe E'Status2 -> Pet)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser [Text]
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "photoUrls")
          Parser (Maybe [Tag] -> Maybe E'Status2 -> Pet)
    -> Parser (Maybe [Tag]) -> Parser (Maybe E'Status2 -> Pet)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Tag])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "tags")
          Parser (Maybe E'Status2 -> Pet)
    -> Parser (Maybe E'Status2) -> Parser Pet
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe E'Status2)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "status")

    -- | ToJSON Pet
    instance A.ToJSON Pet where
      toJSON :: Pet -> Value
    toJSON Pet {[Text]
    Maybe Integer
    Maybe [Tag]
    Maybe E'Status2
    Maybe Category
    Text
    petId :: Pet -> Maybe Integer
    petCategory :: Pet -> Maybe Category
    petName :: Pet -> Text
    petPhotoUrls :: Pet -> [Text]
    petTags :: Pet -> Maybe [Tag]
    petStatus :: Pet -> Maybe E'Status2
    petId :: Maybe Integer
    petCategory :: Maybe Category
    petName :: Text
    petPhotoUrls :: [Text]
    petTags :: Maybe [Tag]
    petStatus :: Maybe E'Status2
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "id" Key -> Maybe Integer -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Integer
    petId
          , Key
    "category" Key -> Maybe Category -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Category
    petCategory
          , Key
    "name" Key -> Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Text
    petName
          , Key
    "photoUrls" Key -> [Text] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= [Text]
    petPhotoUrls
          , Key
    "tags" Key -> Maybe [Tag] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Tag]
    petTags
          , Key
    "status" Key -> Maybe E'Status2 -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe E'Status2
    petStatus
          ]

    -- | Construct a value of type 'Pet' (by applying it's required fields, if any)
    mkPet
      :: Text -- ^ 'petName'
      -> [Text] -- ^ 'petPhotoUrls'
      -> Pet
    mkPet :: Text -> [Text] -> Pet
    mkPet Text
    petName [Text]
    petPhotoUrls =
      Pet
      { petId :: Maybe Integer
    petId = Maybe Integer
    forall a. Maybe a
    Nothing
      , petCategory :: Maybe Category
    petCategory = Maybe Category
    forall a. Maybe a
    Nothing
      , Text
    petName :: Text
    petName :: Text
    petName
      , [Text]
    petPhotoUrls :: [Text]
    petPhotoUrls :: [Text]
    petPhotoUrls
      , petTags :: Maybe [Tag]
    petTags = Maybe [Tag]
    forall a. Maybe a
    Nothing
      , petStatus :: Maybe E'Status2
    petStatus = Maybe E'Status2
    forall a. Maybe a
    Nothing
      }

    -- ** ReadOnlyFirst
    -- | ReadOnlyFirst
    data ReadOnlyFirst = ReadOnlyFirst
      { ReadOnlyFirst -> Maybe Text
    readOnlyFirstBar :: !(Maybe Text) -- ^ /ReadOnly/ "bar"
      , ReadOnlyFirst -> Maybe Text
    readOnlyFirstBaz :: !(Maybe Text) -- ^ "baz"
      } deriving (Int -> ReadOnlyFirst -> ShowS
    [ReadOnlyFirst] -> ShowS
    ReadOnlyFirst -> [Char]
    (Int -> ReadOnlyFirst -> ShowS)
    -> (ReadOnlyFirst -> [Char])
    -> ([ReadOnlyFirst] -> ShowS)
    -> Show ReadOnlyFirst
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ReadOnlyFirst -> ShowS
    showsPrec :: Int -> ReadOnlyFirst -> ShowS
    $cshow :: ReadOnlyFirst -> [Char]
    show :: ReadOnlyFirst -> [Char]
    $cshowList :: [ReadOnlyFirst] -> ShowS
    showList :: [ReadOnlyFirst] -> ShowS
    P.Show, ReadOnlyFirst -> ReadOnlyFirst -> Bool
    (ReadOnlyFirst -> ReadOnlyFirst -> Bool)
    -> (ReadOnlyFirst -> ReadOnlyFirst -> Bool) -> Eq ReadOnlyFirst
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ReadOnlyFirst -> ReadOnlyFirst -> Bool
    == :: ReadOnlyFirst -> ReadOnlyFirst -> Bool
    $c/= :: ReadOnlyFirst -> ReadOnlyFirst -> Bool
    /= :: ReadOnlyFirst -> ReadOnlyFirst -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON ReadOnlyFirst
    instance A.FromJSON ReadOnlyFirst where
      parseJSON :: Value -> Parser ReadOnlyFirst
    parseJSON = [Char]
    -> (Object -> Parser ReadOnlyFirst)
    -> Value
    -> Parser ReadOnlyFirst
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "ReadOnlyFirst" ((Object -> Parser ReadOnlyFirst) -> Value -> Parser ReadOnlyFirst)
    -> (Object -> Parser ReadOnlyFirst)
    -> Value
    -> Parser ReadOnlyFirst
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text -> Maybe Text -> ReadOnlyFirst
    ReadOnlyFirst
          (Maybe Text -> Maybe Text -> ReadOnlyFirst)
    -> Parser (Maybe Text) -> Parser (Maybe Text -> ReadOnlyFirst)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "bar")
          Parser (Maybe Text -> ReadOnlyFirst)
    -> Parser (Maybe Text) -> Parser ReadOnlyFirst
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "baz")

    -- | ToJSON ReadOnlyFirst
    instance A.ToJSON ReadOnlyFirst where
      toJSON :: ReadOnlyFirst -> Value
    toJSON ReadOnlyFirst {Maybe Text
    readOnlyFirstBar :: ReadOnlyFirst -> Maybe Text
    readOnlyFirstBaz :: ReadOnlyFirst -> Maybe Text
    readOnlyFirstBar :: Maybe Text
    readOnlyFirstBaz :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "bar" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    readOnlyFirstBar
          , Key
    "baz" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    readOnlyFirstBaz
          ]

    -- | Construct a value of type 'ReadOnlyFirst' (by applying it's required fields, if any)
    mkReadOnlyFirst
      :: ReadOnlyFirst
    mkReadOnlyFirst :: ReadOnlyFirst
    mkReadOnlyFirst =
      ReadOnlyFirst
      { readOnlyFirstBar :: Maybe Text
    readOnlyFirstBar = Maybe Text
    forall a. Maybe a
    Nothing
      , readOnlyFirstBaz :: Maybe Text
    readOnlyFirstBaz = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** SpecialModelName
    -- | SpecialModelName
    data SpecialModelName = SpecialModelName
      { SpecialModelName -> Maybe Integer
    specialModelNameSpecialPropertyName :: !(Maybe Integer) -- ^ "$special[property.name]"
      } deriving (Int -> SpecialModelName -> ShowS
    [SpecialModelName] -> ShowS
    SpecialModelName -> [Char]
    (Int -> SpecialModelName -> ShowS)
    -> (SpecialModelName -> [Char])
    -> ([SpecialModelName] -> ShowS)
    -> Show SpecialModelName
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SpecialModelName -> ShowS
    showsPrec :: Int -> SpecialModelName -> ShowS
    $cshow :: SpecialModelName -> [Char]
    show :: SpecialModelName -> [Char]
    $cshowList :: [SpecialModelName] -> ShowS
    showList :: [SpecialModelName] -> ShowS
    P.Show, SpecialModelName -> SpecialModelName -> Bool
    (SpecialModelName -> SpecialModelName -> Bool)
    -> (SpecialModelName -> SpecialModelName -> Bool)
    -> Eq SpecialModelName
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SpecialModelName -> SpecialModelName -> Bool
    == :: SpecialModelName -> SpecialModelName -> Bool
    $c/= :: SpecialModelName -> SpecialModelName -> Bool
    /= :: SpecialModelName -> SpecialModelName -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON SpecialModelName
    instance A.FromJSON SpecialModelName where
      parseJSON :: Value -> Parser SpecialModelName
    parseJSON = [Char]
    -> (Object -> Parser SpecialModelName)
    -> Value
    -> Parser SpecialModelName
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "SpecialModelName" ((Object -> Parser SpecialModelName)
     -> Value -> Parser SpecialModelName)
    -> (Object -> Parser SpecialModelName)
    -> Value
    -> Parser SpecialModelName
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Integer -> SpecialModelName
    SpecialModelName
          (Maybe Integer -> SpecialModelName)
    -> Parser (Maybe Integer) -> Parser SpecialModelName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Integer)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "$special[property.name]")

    -- | ToJSON SpecialModelName
    instance A.ToJSON SpecialModelName where
      toJSON :: SpecialModelName -> Value
    toJSON SpecialModelName {Maybe Integer
    specialModelNameSpecialPropertyName :: SpecialModelName -> Maybe Integer
    specialModelNameSpecialPropertyName :: Maybe Integer
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "$special[property.name]" Key -> Maybe Integer -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Integer
    specialModelNameSpecialPropertyName
          ]

    -- | Construct a value of type 'SpecialModelName' (by applying it's required fields, if any)
    mkSpecialModelName
      :: SpecialModelName
    mkSpecialModelName :: SpecialModelName
    mkSpecialModelName =
      SpecialModelName
      { specialModelNameSpecialPropertyName :: Maybe Integer
    specialModelNameSpecialPropertyName = Maybe Integer
    forall a. Maybe a
    Nothing
      }

    -- ** Tag
    -- | Tag
    data Tag = Tag
      { Tag -> Maybe Integer
    tagId :: !(Maybe Integer) -- ^ "id"
      , Tag -> Maybe Text
    tagName :: !(Maybe Text) -- ^ "name"
      } deriving (Int -> Tag -> ShowS
    [Tag] -> ShowS
    Tag -> [Char]
    (Int -> Tag -> ShowS)
    -> (Tag -> [Char]) -> ([Tag] -> ShowS) -> Show Tag
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Tag -> ShowS
    showsPrec :: Int -> Tag -> ShowS
    $cshow :: Tag -> [Char]
    show :: Tag -> [Char]
    $cshowList :: [Tag] -> ShowS
    showList :: [Tag] -> ShowS
    P.Show, Tag -> Tag -> Bool
    (Tag -> Tag -> Bool) -> (Tag -> Tag -> Bool) -> Eq Tag
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Tag -> Tag -> Bool
    == :: Tag -> Tag -> Bool
    $c/= :: Tag -> Tag -> Bool
    /= :: Tag -> Tag -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON Tag
    instance A.FromJSON Tag where
      parseJSON :: Value -> Parser Tag
    parseJSON = [Char] -> (Object -> Parser Tag) -> Value -> Parser Tag
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "Tag" ((Object -> Parser Tag) -> Value -> Parser Tag)
    -> (Object -> Parser Tag) -> Value -> Parser Tag
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Integer -> Maybe Text -> Tag
    Tag
          (Maybe Integer -> Maybe Text -> Tag)
    -> Parser (Maybe Integer) -> Parser (Maybe Text -> Tag)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Integer)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "id")
          Parser (Maybe Text -> Tag) -> Parser (Maybe Text) -> Parser Tag
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name")

    -- | ToJSON Tag
    instance A.ToJSON Tag where
      toJSON :: Tag -> Value
    toJSON Tag {Maybe Integer
    Maybe Text
    tagId :: Tag -> Maybe Integer
    tagName :: Tag -> Maybe Text
    tagId :: Maybe Integer
    tagName :: Maybe Text
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "id" Key -> Maybe Integer -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Integer
    tagId
          , Key
    "name" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    tagName
          ]

    -- | Construct a value of type 'Tag' (by applying it's required fields, if any)
    mkTag
      :: Tag
    mkTag :: Tag
    mkTag =
      Tag
      { tagId :: Maybe Integer
    tagId = Maybe Integer
    forall a. Maybe a
    Nothing
      , tagName :: Maybe Text
    tagName = Maybe Text
    forall a. Maybe a
    Nothing
      }

    -- ** TypeHolderDefault
    -- | TypeHolderDefault
    data TypeHolderDefault = TypeHolderDefault
      { TypeHolderDefault -> Text
    typeHolderDefaultStringItem :: !(Text) -- ^ /Required/ "string_item"
      , TypeHolderDefault -> Double
    typeHolderDefaultNumberItem :: !(Double) -- ^ /Required/ "number_item"
      , TypeHolderDefault -> Int
    typeHolderDefaultIntegerItem :: !(Int) -- ^ /Required/ "integer_item"
      , TypeHolderDefault -> Bool
    typeHolderDefaultBoolItem :: !(Bool) -- ^ /Required/ "bool_item"
      , TypeHolderDefault -> [Int]
    typeHolderDefaultArrayItem :: !([Int]) -- ^ /Required/ "array_item"
      } deriving (Int -> TypeHolderDefault -> ShowS
    [TypeHolderDefault] -> ShowS
    TypeHolderDefault -> [Char]
    (Int -> TypeHolderDefault -> ShowS)
    -> (TypeHolderDefault -> [Char])
    -> ([TypeHolderDefault] -> ShowS)
    -> Show TypeHolderDefault
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TypeHolderDefault -> ShowS
    showsPrec :: Int -> TypeHolderDefault -> ShowS
    $cshow :: TypeHolderDefault -> [Char]
    show :: TypeHolderDefault -> [Char]
    $cshowList :: [TypeHolderDefault] -> ShowS
    showList :: [TypeHolderDefault] -> ShowS
    P.Show, TypeHolderDefault -> TypeHolderDefault -> Bool
    (TypeHolderDefault -> TypeHolderDefault -> Bool)
    -> (TypeHolderDefault -> TypeHolderDefault -> Bool)
    -> Eq TypeHolderDefault
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TypeHolderDefault -> TypeHolderDefault -> Bool
    == :: TypeHolderDefault -> TypeHolderDefault -> Bool
    $c/= :: TypeHolderDefault -> TypeHolderDefault -> Bool
    /= :: TypeHolderDefault -> TypeHolderDefault -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON TypeHolderDefault
    instance A.FromJSON TypeHolderDefault where
      parseJSON :: Value -> Parser TypeHolderDefault
    parseJSON = [Char]
    -> (Object -> Parser TypeHolderDefault)
    -> Value
    -> Parser TypeHolderDefault
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "TypeHolderDefault" ((Object -> Parser TypeHolderDefault)
     -> Value -> Parser TypeHolderDefault)
    -> (Object -> Parser TypeHolderDefault)
    -> Value
    -> Parser TypeHolderDefault
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Text -> Double -> Int -> Bool -> [Int] -> TypeHolderDefault
    TypeHolderDefault
          (Text -> Double -> Int -> Bool -> [Int] -> TypeHolderDefault)
    -> Parser Text
    -> Parser (Double -> Int -> Bool -> [Int] -> TypeHolderDefault)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser Text
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "string_item")
          Parser (Double -> Int -> Bool -> [Int] -> TypeHolderDefault)
    -> Parser Double
    -> Parser (Int -> Bool -> [Int] -> TypeHolderDefault)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Double
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "number_item")
          Parser (Int -> Bool -> [Int] -> TypeHolderDefault)
    -> Parser Int -> Parser (Bool -> [Int] -> TypeHolderDefault)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Int
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "integer_item")
          Parser (Bool -> [Int] -> TypeHolderDefault)
    -> Parser Bool -> Parser ([Int] -> TypeHolderDefault)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Bool
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "bool_item")
          Parser ([Int] -> TypeHolderDefault)
    -> Parser [Int] -> Parser TypeHolderDefault
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser [Int]
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "array_item")

    -- | ToJSON TypeHolderDefault
    instance A.ToJSON TypeHolderDefault where
      toJSON :: TypeHolderDefault -> Value
    toJSON TypeHolderDefault {Bool
    Double
    Int
    [Int]
    Text
    typeHolderDefaultStringItem :: TypeHolderDefault -> Text
    typeHolderDefaultNumberItem :: TypeHolderDefault -> Double
    typeHolderDefaultIntegerItem :: TypeHolderDefault -> Int
    typeHolderDefaultBoolItem :: TypeHolderDefault -> Bool
    typeHolderDefaultArrayItem :: TypeHolderDefault -> [Int]
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultArrayItem :: [Int]
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "string_item" Key -> Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Text
    typeHolderDefaultStringItem
          , Key
    "number_item" Key -> Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Double
    typeHolderDefaultNumberItem
          , Key
    "integer_item" Key -> Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Int
    typeHolderDefaultIntegerItem
          , Key
    "bool_item" Key -> Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Bool
    typeHolderDefaultBoolItem
          , Key
    "array_item" Key -> [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= [Int]
    typeHolderDefaultArrayItem
          ]

    -- | Construct a value of type 'TypeHolderDefault' (by applying it's required fields, if any)
    mkTypeHolderDefault
      :: Text -- ^ 'typeHolderDefaultStringItem'
      -> Double -- ^ 'typeHolderDefaultNumberItem'
      -> Int -- ^ 'typeHolderDefaultIntegerItem'
      -> Bool -- ^ 'typeHolderDefaultBoolItem'
      -> [Int] -- ^ 'typeHolderDefaultArrayItem'
      -> TypeHolderDefault
    mkTypeHolderDefault :: Text -> Double -> Int -> Bool -> [Int] -> TypeHolderDefault
    mkTypeHolderDefault Text
    typeHolderDefaultStringItem Double
    typeHolderDefaultNumberItem Int
    typeHolderDefaultIntegerItem Bool
    typeHolderDefaultBoolItem [Int]
    typeHolderDefaultArrayItem =
      TypeHolderDefault
      { Text
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultStringItem :: Text
    typeHolderDefaultStringItem
      , Double
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultNumberItem :: Double
    typeHolderDefaultNumberItem
      , Int
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultIntegerItem :: Int
    typeHolderDefaultIntegerItem
      , Bool
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultBoolItem :: Bool
    typeHolderDefaultBoolItem
      , [Int]
    typeHolderDefaultArrayItem :: [Int]
    typeHolderDefaultArrayItem :: [Int]
    typeHolderDefaultArrayItem
      }

    -- ** TypeHolderExample
    -- | TypeHolderExample
    data TypeHolderExample = TypeHolderExample
      { TypeHolderExample -> Text
    typeHolderExampleStringItem :: !(Text) -- ^ /Required/ "string_item"
      , TypeHolderExample -> Double
    typeHolderExampleNumberItem :: !(Double) -- ^ /Required/ "number_item"
      , TypeHolderExample -> Float
    typeHolderExampleFloatItem :: !(Float) -- ^ /Required/ "float_item"
      , TypeHolderExample -> Int
    typeHolderExampleIntegerItem :: !(Int) -- ^ /Required/ "integer_item"
      , TypeHolderExample -> Bool
    typeHolderExampleBoolItem :: !(Bool) -- ^ /Required/ "bool_item"
      , TypeHolderExample -> [Int]
    typeHolderExampleArrayItem :: !([Int]) -- ^ /Required/ "array_item"
      } deriving (Int -> TypeHolderExample -> ShowS
    [TypeHolderExample] -> ShowS
    TypeHolderExample -> [Char]
    (Int -> TypeHolderExample -> ShowS)
    -> (TypeHolderExample -> [Char])
    -> ([TypeHolderExample] -> ShowS)
    -> Show TypeHolderExample
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TypeHolderExample -> ShowS
    showsPrec :: Int -> TypeHolderExample -> ShowS
    $cshow :: TypeHolderExample -> [Char]
    show :: TypeHolderExample -> [Char]
    $cshowList :: [TypeHolderExample] -> ShowS
    showList :: [TypeHolderExample] -> ShowS
    P.Show, TypeHolderExample -> TypeHolderExample -> Bool
    (TypeHolderExample -> TypeHolderExample -> Bool)
    -> (TypeHolderExample -> TypeHolderExample -> Bool)
    -> Eq TypeHolderExample
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TypeHolderExample -> TypeHolderExample -> Bool
    == :: TypeHolderExample -> TypeHolderExample -> Bool
    $c/= :: TypeHolderExample -> TypeHolderExample -> Bool
    /= :: TypeHolderExample -> TypeHolderExample -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON TypeHolderExample
    instance A.FromJSON TypeHolderExample where
      parseJSON :: Value -> Parser TypeHolderExample
    parseJSON = [Char]
    -> (Object -> Parser TypeHolderExample)
    -> Value
    -> Parser TypeHolderExample
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "TypeHolderExample" ((Object -> Parser TypeHolderExample)
     -> Value -> Parser TypeHolderExample)
    -> (Object -> Parser TypeHolderExample)
    -> Value
    -> Parser TypeHolderExample
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Text
    -> Double -> Float -> Int -> Bool -> [Int] -> TypeHolderExample
    TypeHolderExample
          (Text
     -> Double -> Float -> Int -> Bool -> [Int] -> TypeHolderExample)
    -> Parser Text
    -> Parser
         (Double -> Float -> Int -> Bool -> [Int] -> TypeHolderExample)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser Text
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "string_item")
          Parser
      (Double -> Float -> Int -> Bool -> [Int] -> TypeHolderExample)
    -> Parser Double
    -> Parser (Float -> Int -> Bool -> [Int] -> TypeHolderExample)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Double
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "number_item")
          Parser (Float -> Int -> Bool -> [Int] -> TypeHolderExample)
    -> Parser Float
    -> Parser (Int -> Bool -> [Int] -> TypeHolderExample)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Float
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "float_item")
          Parser (Int -> Bool -> [Int] -> TypeHolderExample)
    -> Parser Int -> Parser (Bool -> [Int] -> TypeHolderExample)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Int
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "integer_item")
          Parser (Bool -> [Int] -> TypeHolderExample)
    -> Parser Bool -> Parser ([Int] -> TypeHolderExample)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser Bool
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "bool_item")
          Parser ([Int] -> TypeHolderExample)
    -> Parser [Int] -> Parser TypeHolderExample
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser [Int]
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "array_item")

    -- | ToJSON TypeHolderExample
    instance A.ToJSON TypeHolderExample where
      toJSON :: TypeHolderExample -> Value
    toJSON TypeHolderExample {Bool
    Double
    Float
    Int
    [Int]
    Text
    typeHolderExampleStringItem :: TypeHolderExample -> Text
    typeHolderExampleNumberItem :: TypeHolderExample -> Double
    typeHolderExampleFloatItem :: TypeHolderExample -> Float
    typeHolderExampleIntegerItem :: TypeHolderExample -> Int
    typeHolderExampleBoolItem :: TypeHolderExample -> Bool
    typeHolderExampleArrayItem :: TypeHolderExample -> [Int]
    typeHolderExampleStringItem :: Text
    typeHolderExampleNumberItem :: Double
    typeHolderExampleFloatItem :: Float
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleArrayItem :: [Int]
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "string_item" Key -> Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Text
    typeHolderExampleStringItem
          , Key
    "number_item" Key -> Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Double
    typeHolderExampleNumberItem
          , Key
    "float_item" Key -> Float -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Float
    typeHolderExampleFloatItem
          , Key
    "integer_item" Key -> Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Int
    typeHolderExampleIntegerItem
          , Key
    "bool_item" Key -> Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Bool
    typeHolderExampleBoolItem
          , Key
    "array_item" Key -> [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= [Int]
    typeHolderExampleArrayItem
          ]

    -- | Construct a value of type 'TypeHolderExample' (by applying it's required fields, if any)
    mkTypeHolderExample
      :: Text -- ^ 'typeHolderExampleStringItem'
      -> Double -- ^ 'typeHolderExampleNumberItem'
      -> Float -- ^ 'typeHolderExampleFloatItem'
      -> Int -- ^ 'typeHolderExampleIntegerItem'
      -> Bool -- ^ 'typeHolderExampleBoolItem'
      -> [Int] -- ^ 'typeHolderExampleArrayItem'
      -> TypeHolderExample
    mkTypeHolderExample :: Text
    -> Double -> Float -> Int -> Bool -> [Int] -> TypeHolderExample
    mkTypeHolderExample Text
    typeHolderExampleStringItem Double
    typeHolderExampleNumberItem Float
    typeHolderExampleFloatItem Int
    typeHolderExampleIntegerItem Bool
    typeHolderExampleBoolItem [Int]
    typeHolderExampleArrayItem =
      TypeHolderExample
      { Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleStringItem :: Text
    typeHolderExampleStringItem
      , Double
    typeHolderExampleNumberItem :: Double
    typeHolderExampleNumberItem :: Double
    typeHolderExampleNumberItem
      , Float
    typeHolderExampleFloatItem :: Float
    typeHolderExampleFloatItem :: Float
    typeHolderExampleFloatItem
      , Int
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleIntegerItem :: Int
    typeHolderExampleIntegerItem
      , Bool
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleBoolItem :: Bool
    typeHolderExampleBoolItem
      , [Int]
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleArrayItem :: [Int]
    typeHolderExampleArrayItem
      }

    -- ** User
    -- | User
    data User = User
      { User -> Maybe Integer
    userId :: !(Maybe Integer) -- ^ "id"
      , User -> Maybe Text
    userUsername :: !(Maybe Text) -- ^ "username"
      , User -> Maybe Text
    userFirstName :: !(Maybe Text) -- ^ "firstName"
      , User -> Maybe Text
    userLastName :: !(Maybe Text) -- ^ "lastName"
      , User -> Maybe Text
    userEmail :: !(Maybe Text) -- ^ "email"
      , User -> Maybe Text
    userPassword :: !(Maybe Text) -- ^ "password"
      , User -> Maybe Text
    userPhone :: !(Maybe Text) -- ^ "phone"
      , User -> Maybe Int
    userUserStatus :: !(Maybe Int) -- ^ "userStatus" - User Status
      } deriving (Int -> User -> ShowS
    [User] -> ShowS
    User -> [Char]
    (Int -> User -> ShowS)
    -> (User -> [Char]) -> ([User] -> ShowS) -> Show User
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> User -> ShowS
    showsPrec :: Int -> User -> ShowS
    $cshow :: User -> [Char]
    show :: User -> [Char]
    $cshowList :: [User] -> ShowS
    showList :: [User] -> ShowS
    P.Show, User -> User -> Bool
    (User -> User -> Bool) -> (User -> User -> Bool) -> Eq User
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: User -> User -> Bool
    == :: User -> User -> Bool
    $c/= :: User -> User -> Bool
    /= :: User -> User -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON User
    instance A.FromJSON User where
      parseJSON :: Value -> Parser User
    parseJSON = [Char] -> (Object -> Parser User) -> Value -> Parser User
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "User" ((Object -> Parser User) -> Value -> Parser User)
    -> (Object -> Parser User) -> Value -> Parser User
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Integer
    -> Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> Maybe Int
    -> User
    User
          (Maybe Integer
     -> Maybe Text
     -> Maybe Text
     -> Maybe Text
     -> Maybe Text
     -> Maybe Text
     -> Maybe Text
     -> Maybe Int
     -> User)
    -> Parser (Maybe Integer)
    -> Parser
         (Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Maybe Int
          -> User)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Integer)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "id")
          Parser
      (Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Maybe Int
       -> User)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Maybe Text
          -> Maybe Int
          -> User)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "username")
          Parser
      (Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Maybe Text
       -> Maybe Int
       -> User)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Text
          -> Maybe Text -> Maybe Text -> Maybe Text -> Maybe Int -> User)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "firstName")
          Parser
      (Maybe Text
       -> Maybe Text -> Maybe Text -> Maybe Text -> Maybe Int -> User)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Text -> Maybe Text -> Maybe Text -> Maybe Int -> User)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "lastName")
          Parser
      (Maybe Text -> Maybe Text -> Maybe Text -> Maybe Int -> User)
    -> Parser (Maybe Text)
    -> Parser (Maybe Text -> Maybe Text -> Maybe Int -> User)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "email")
          Parser (Maybe Text -> Maybe Text -> Maybe Int -> User)
    -> Parser (Maybe Text) -> Parser (Maybe Text -> Maybe Int -> User)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "password")
          Parser (Maybe Text -> Maybe Int -> User)
    -> Parser (Maybe Text) -> Parser (Maybe Int -> User)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "phone")
          Parser (Maybe Int -> User) -> Parser (Maybe Int) -> Parser User
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "userStatus")

    -- | ToJSON User
    instance A.ToJSON User where
      toJSON :: User -> Value
    toJSON User {Maybe Int
    Maybe Integer
    Maybe Text
    userId :: User -> Maybe Integer
    userUsername :: User -> Maybe Text
    userFirstName :: User -> Maybe Text
    userLastName :: User -> Maybe Text
    userEmail :: User -> Maybe Text
    userPassword :: User -> Maybe Text
    userPhone :: User -> Maybe Text
    userUserStatus :: User -> Maybe Int
    userId :: Maybe Integer
    userUsername :: Maybe Text
    userFirstName :: Maybe Text
    userLastName :: Maybe Text
    userEmail :: Maybe Text
    userPassword :: Maybe Text
    userPhone :: Maybe Text
    userUserStatus :: Maybe Int
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "id" Key -> Maybe Integer -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Integer
    userId
          , Key
    "username" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    userUsername
          , Key
    "firstName" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    userFirstName
          , Key
    "lastName" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    userLastName
          , Key
    "email" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    userEmail
          , Key
    "password" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    userPassword
          , Key
    "phone" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    userPhone
          , Key
    "userStatus" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    userUserStatus
          ]

    -- | Construct a value of type 'User' (by applying it's required fields, if any)
    mkUser
      :: User
    mkUser :: User
    mkUser =
      User
      { userId :: Maybe Integer
    userId = Maybe Integer
    forall a. Maybe a
    Nothing
      , userUsername :: Maybe Text
    userUsername = Maybe Text
    forall a. Maybe a
    Nothing
      , userFirstName :: Maybe Text
    userFirstName = Maybe Text
    forall a. Maybe a
    Nothing
      , userLastName :: Maybe Text
    userLastName = Maybe Text
    forall a. Maybe a
    Nothing
      , userEmail :: Maybe Text
    userEmail = Maybe Text
    forall a. Maybe a
    Nothing
      , userPassword :: Maybe Text
    userPassword = Maybe Text
    forall a. Maybe a
    Nothing
      , userPhone :: Maybe Text
    userPhone = Maybe Text
    forall a. Maybe a
    Nothing
      , userUserStatus :: Maybe Int
    userUserStatus = Maybe Int
    forall a. Maybe a
    Nothing
      }

    -- ** XmlItem
    -- | XmlItem
    data XmlItem = XmlItem
      { XmlItem -> Maybe Text
    xmlItemAttributeString :: !(Maybe Text) -- ^ "attribute_string"
      , XmlItem -> Maybe Double
    xmlItemAttributeNumber :: !(Maybe Double) -- ^ "attribute_number"
      , XmlItem -> Maybe Int
    xmlItemAttributeInteger :: !(Maybe Int) -- ^ "attribute_integer"
      , XmlItem -> Maybe Bool
    xmlItemAttributeBoolean :: !(Maybe Bool) -- ^ "attribute_boolean"
      , XmlItem -> Maybe [Int]
    xmlItemWrappedArray :: !(Maybe [Int]) -- ^ "wrapped_array"
      , XmlItem -> Maybe Text
    xmlItemNameString :: !(Maybe Text) -- ^ "name_string"
      , XmlItem -> Maybe Double
    xmlItemNameNumber :: !(Maybe Double) -- ^ "name_number"
      , XmlItem -> Maybe Int
    xmlItemNameInteger :: !(Maybe Int) -- ^ "name_integer"
      , XmlItem -> Maybe Bool
    xmlItemNameBoolean :: !(Maybe Bool) -- ^ "name_boolean"
      , XmlItem -> Maybe [Int]
    xmlItemNameArray :: !(Maybe [Int]) -- ^ "name_array"
      , XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: !(Maybe [Int]) -- ^ "name_wrapped_array"
      , XmlItem -> Maybe Text
    xmlItemPrefixString :: !(Maybe Text) -- ^ "prefix_string"
      , XmlItem -> Maybe Double
    xmlItemPrefixNumber :: !(Maybe Double) -- ^ "prefix_number"
      , XmlItem -> Maybe Int
    xmlItemPrefixInteger :: !(Maybe Int) -- ^ "prefix_integer"
      , XmlItem -> Maybe Bool
    xmlItemPrefixBoolean :: !(Maybe Bool) -- ^ "prefix_boolean"
      , XmlItem -> Maybe [Int]
    xmlItemPrefixArray :: !(Maybe [Int]) -- ^ "prefix_array"
      , XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: !(Maybe [Int]) -- ^ "prefix_wrapped_array"
      , XmlItem -> Maybe Text
    xmlItemNamespaceString :: !(Maybe Text) -- ^ "namespace_string"
      , XmlItem -> Maybe Double
    xmlItemNamespaceNumber :: !(Maybe Double) -- ^ "namespace_number"
      , XmlItem -> Maybe Int
    xmlItemNamespaceInteger :: !(Maybe Int) -- ^ "namespace_integer"
      , XmlItem -> Maybe Bool
    xmlItemNamespaceBoolean :: !(Maybe Bool) -- ^ "namespace_boolean"
      , XmlItem -> Maybe [Int]
    xmlItemNamespaceArray :: !(Maybe [Int]) -- ^ "namespace_array"
      , XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: !(Maybe [Int]) -- ^ "namespace_wrapped_array"
      , XmlItem -> Maybe Text
    xmlItemPrefixNsString :: !(Maybe Text) -- ^ "prefix_ns_string"
      , XmlItem -> Maybe Double
    xmlItemPrefixNsNumber :: !(Maybe Double) -- ^ "prefix_ns_number"
      , XmlItem -> Maybe Int
    xmlItemPrefixNsInteger :: !(Maybe Int) -- ^ "prefix_ns_integer"
      , XmlItem -> Maybe Bool
    xmlItemPrefixNsBoolean :: !(Maybe Bool) -- ^ "prefix_ns_boolean"
      , XmlItem -> Maybe [Int]
    xmlItemPrefixNsArray :: !(Maybe [Int]) -- ^ "prefix_ns_array"
      , XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: !(Maybe [Int]) -- ^ "prefix_ns_wrapped_array"
      } deriving (Int -> XmlItem -> ShowS
    [XmlItem] -> ShowS
    XmlItem -> [Char]
    (Int -> XmlItem -> ShowS)
    -> (XmlItem -> [Char]) -> ([XmlItem] -> ShowS) -> Show XmlItem
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> XmlItem -> ShowS
    showsPrec :: Int -> XmlItem -> ShowS
    $cshow :: XmlItem -> [Char]
    show :: XmlItem -> [Char]
    $cshowList :: [XmlItem] -> ShowS
    showList :: [XmlItem] -> ShowS
    P.Show, XmlItem -> XmlItem -> Bool
    (XmlItem -> XmlItem -> Bool)
    -> (XmlItem -> XmlItem -> Bool) -> Eq XmlItem
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: XmlItem -> XmlItem -> Bool
    == :: XmlItem -> XmlItem -> Bool
    $c/= :: XmlItem -> XmlItem -> Bool
    /= :: XmlItem -> XmlItem -> Bool
    P.Eq, P.Typeable)

    -- | FromJSON XmlItem
    instance A.FromJSON XmlItem where
      parseJSON :: Value -> Parser XmlItem
    parseJSON = [Char] -> (Object -> Parser XmlItem) -> Value -> Parser XmlItem
    forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
    A.withObject [Char]
    "XmlItem" ((Object -> Parser XmlItem) -> Value -> Parser XmlItem)
    -> (Object -> Parser XmlItem) -> Value -> Parser XmlItem
    forall a b. (a -> b) -> a -> b
    $ \Object
    o ->
        Maybe Text
    -> Maybe Double
    -> Maybe Int
    -> Maybe Bool
    -> Maybe [Int]
    -> Maybe Text
    -> Maybe Double
    -> Maybe Int
    -> Maybe Bool
    -> Maybe [Int]
    -> Maybe [Int]
    -> Maybe Text
    -> Maybe Double
    -> Maybe Int
    -> Maybe Bool
    -> Maybe [Int]
    -> Maybe [Int]
    -> Maybe Text
    -> Maybe Double
    -> Maybe Int
    -> Maybe Bool
    -> Maybe [Int]
    -> Maybe [Int]
    -> Maybe Text
    -> Maybe Double
    -> Maybe Int
    -> Maybe Bool
    -> Maybe [Int]
    -> Maybe [Int]
    -> XmlItem
    XmlItem
          (Maybe Text
     -> Maybe Double
     -> Maybe Int
     -> Maybe Bool
     -> Maybe [Int]
     -> Maybe Text
     -> Maybe Double
     -> Maybe Int
     -> Maybe Bool
     -> Maybe [Int]
     -> Maybe [Int]
     -> Maybe Text
     -> Maybe Double
     -> Maybe Int
     -> Maybe Bool
     -> Maybe [Int]
     -> Maybe [Int]
     -> Maybe Text
     -> Maybe Double
     -> Maybe Int
     -> Maybe Bool
     -> Maybe [Int]
     -> Maybe [Int]
     -> Maybe Text
     -> Maybe Double
     -> Maybe Int
     -> Maybe Bool
     -> Maybe [Int]
     -> Maybe [Int]
     -> XmlItem)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "attribute_string")
          Parser
      (Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Double)
    -> Parser
         (Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Double)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "attribute_number")
          Parser
      (Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Int)
    -> Parser
         (Maybe Bool
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "attribute_integer")
          Parser
      (Maybe Bool
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Bool)
    -> Parser
         (Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Bool)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "attribute_boolean")
          Parser
      (Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe [Int])
    -> Parser
         (Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "wrapped_array")
          Parser
      (Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name_string")
          Parser
      (Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Double)
    -> Parser
         (Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Double)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name_number")
          Parser
      (Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Int)
    -> Parser
         (Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name_integer")
          Parser
      (Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Bool)
    -> Parser
         (Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Bool)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name_boolean")
          Parser
      (Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe [Int])
    -> Parser
         (Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name_array")
          Parser
      (Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe [Int])
    -> Parser
         (Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "name_wrapped_array")
          Parser
      (Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_string")
          Parser
      (Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Double)
    -> Parser
         (Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Double)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_number")
          Parser
      (Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Int)
    -> Parser
         (Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_integer")
          Parser
      (Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Bool)
    -> Parser
         (Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Bool)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_boolean")
          Parser
      (Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe [Int])
    -> Parser
         (Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_array")
          Parser
      (Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe [Int])
    -> Parser
         (Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_wrapped_array")
          Parser
      (Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "namespace_string")
          Parser
      (Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Double)
    -> Parser
         (Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Double)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "namespace_number")
          Parser
      (Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Int)
    -> Parser
         (Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "namespace_integer")
          Parser
      (Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Bool)
    -> Parser
         (Maybe [Int]
          -> Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Bool)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "namespace_boolean")
          Parser
      (Maybe [Int]
       -> Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe [Int])
    -> Parser
         (Maybe [Int]
          -> Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "namespace_array")
          Parser
      (Maybe [Int]
       -> Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe [Int])
    -> Parser
         (Maybe Text
          -> Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "namespace_wrapped_array")
          Parser
      (Maybe Text
       -> Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Text)
    -> Parser
         (Maybe Double
          -> Maybe Int
          -> Maybe Bool
          -> Maybe [Int]
          -> Maybe [Int]
          -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Text)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_ns_string")
          Parser
      (Maybe Double
       -> Maybe Int
       -> Maybe Bool
       -> Maybe [Int]
       -> Maybe [Int]
       -> XmlItem)
    -> Parser (Maybe Double)
    -> Parser
         (Maybe Int -> Maybe Bool -> Maybe [Int] -> Maybe [Int] -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Double)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_ns_number")
          Parser
      (Maybe Int -> Maybe Bool -> Maybe [Int] -> Maybe [Int] -> XmlItem)
    -> Parser (Maybe Int)
    -> Parser (Maybe Bool -> Maybe [Int] -> Maybe [Int] -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Int)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_ns_integer")
          Parser (Maybe Bool -> Maybe [Int] -> Maybe [Int] -> XmlItem)
    -> Parser (Maybe Bool)
    -> Parser (Maybe [Int] -> Maybe [Int] -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe Bool)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_ns_boolean")
          Parser (Maybe [Int] -> Maybe [Int] -> XmlItem)
    -> Parser (Maybe [Int]) -> Parser (Maybe [Int] -> XmlItem)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_ns_array")
          Parser (Maybe [Int] -> XmlItem)
    -> Parser (Maybe [Int]) -> Parser XmlItem
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Object
    o Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "prefix_ns_wrapped_array")

    -- | ToJSON XmlItem
    instance A.ToJSON XmlItem where
      toJSON :: XmlItem -> Value
    toJSON XmlItem {Maybe Bool
    Maybe Double
    Maybe Int
    Maybe [Int]
    Maybe Text
    xmlItemAttributeString :: XmlItem -> Maybe Text
    xmlItemAttributeNumber :: XmlItem -> Maybe Double
    xmlItemAttributeInteger :: XmlItem -> Maybe Int
    xmlItemAttributeBoolean :: XmlItem -> Maybe Bool
    xmlItemWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNameString :: XmlItem -> Maybe Text
    xmlItemNameNumber :: XmlItem -> Maybe Double
    xmlItemNameInteger :: XmlItem -> Maybe Int
    xmlItemNameBoolean :: XmlItem -> Maybe Bool
    xmlItemNameArray :: XmlItem -> Maybe [Int]
    xmlItemNameWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixString :: XmlItem -> Maybe Text
    xmlItemPrefixNumber :: XmlItem -> Maybe Double
    xmlItemPrefixInteger :: XmlItem -> Maybe Int
    xmlItemPrefixBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceString :: XmlItem -> Maybe Text
    xmlItemNamespaceNumber :: XmlItem -> Maybe Double
    xmlItemNamespaceInteger :: XmlItem -> Maybe Int
    xmlItemNamespaceBoolean :: XmlItem -> Maybe Bool
    xmlItemNamespaceArray :: XmlItem -> Maybe [Int]
    xmlItemNamespaceWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsString :: XmlItem -> Maybe Text
    xmlItemPrefixNsNumber :: XmlItem -> Maybe Double
    xmlItemPrefixNsInteger :: XmlItem -> Maybe Int
    xmlItemPrefixNsBoolean :: XmlItem -> Maybe Bool
    xmlItemPrefixNsArray :: XmlItem -> Maybe [Int]
    xmlItemPrefixNsWrappedArray :: XmlItem -> Maybe [Int]
    xmlItemAttributeString :: Maybe Text
    xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeBoolean :: Maybe Bool
    xmlItemWrappedArray :: Maybe [Int]
    xmlItemNameString :: Maybe Text
    xmlItemNameNumber :: Maybe Double
    xmlItemNameInteger :: Maybe Int
    xmlItemNameBoolean :: Maybe Bool
    xmlItemNameArray :: Maybe [Int]
    xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemPrefixString :: Maybe Text
    xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray :: Maybe [Int]
    ..} =
       [(Key, Value)] -> Value
    _omitNulls
          [ Key
    "attribute_string" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    xmlItemAttributeString
          , Key
    "attribute_number" Key -> Maybe Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Double
    xmlItemAttributeNumber
          , Key
    "attribute_integer" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    xmlItemAttributeInteger
          , Key
    "attribute_boolean" Key -> Maybe Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Bool
    xmlItemAttributeBoolean
          , Key
    "wrapped_array" Key -> Maybe [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Int]
    xmlItemWrappedArray
          , Key
    "name_string" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    xmlItemNameString
          , Key
    "name_number" Key -> Maybe Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Double
    xmlItemNameNumber
          , Key
    "name_integer" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    xmlItemNameInteger
          , Key
    "name_boolean" Key -> Maybe Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Bool
    xmlItemNameBoolean
          , Key
    "name_array" Key -> Maybe [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Int]
    xmlItemNameArray
          , Key
    "name_wrapped_array" Key -> Maybe [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Int]
    xmlItemNameWrappedArray
          , Key
    "prefix_string" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    xmlItemPrefixString
          , Key
    "prefix_number" Key -> Maybe Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Double
    xmlItemPrefixNumber
          , Key
    "prefix_integer" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    xmlItemPrefixInteger
          , Key
    "prefix_boolean" Key -> Maybe Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Bool
    xmlItemPrefixBoolean
          , Key
    "prefix_array" Key -> Maybe [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Int]
    xmlItemPrefixArray
          , Key
    "prefix_wrapped_array" Key -> Maybe [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Int]
    xmlItemPrefixWrappedArray
          , Key
    "namespace_string" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    xmlItemNamespaceString
          , Key
    "namespace_number" Key -> Maybe Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Double
    xmlItemNamespaceNumber
          , Key
    "namespace_integer" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    xmlItemNamespaceInteger
          , Key
    "namespace_boolean" Key -> Maybe Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Bool
    xmlItemNamespaceBoolean
          , Key
    "namespace_array" Key -> Maybe [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Int]
    xmlItemNamespaceArray
          , Key
    "namespace_wrapped_array" Key -> Maybe [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Int]
    xmlItemNamespaceWrappedArray
          , Key
    "prefix_ns_string" Key -> Maybe Text -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Text
    xmlItemPrefixNsString
          , Key
    "prefix_ns_number" Key -> Maybe Double -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Double
    xmlItemPrefixNsNumber
          , Key
    "prefix_ns_integer" Key -> Maybe Int -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Int
    xmlItemPrefixNsInteger
          , Key
    "prefix_ns_boolean" Key -> Maybe Bool -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe Bool
    xmlItemPrefixNsBoolean
          , Key
    "prefix_ns_array" Key -> Maybe [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Int]
    xmlItemPrefixNsArray
          , Key
    "prefix_ns_wrapped_array" Key -> Maybe [Int] -> (Key, Value)
    forall v. ToJSON v => Key -> v -> (Key, Value)
    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
    .= Maybe [Int]
    xmlItemPrefixNsWrappedArray
          ]

    -- | Construct a value of type 'XmlItem' (by applying it's required fields, if any)
    mkXmlItem
      :: XmlItem
    mkXmlItem :: XmlItem
    mkXmlItem =
      XmlItem
      { xmlItemAttributeString :: Maybe Text
    xmlItemAttributeString = Maybe Text
    forall a. Maybe a
    Nothing
      , xmlItemAttributeNumber :: Maybe Double
    xmlItemAttributeNumber = Maybe Double
    forall a. Maybe a
    Nothing
      , xmlItemAttributeInteger :: Maybe Int
    xmlItemAttributeInteger = Maybe Int
    forall a. Maybe a
    Nothing
      , xmlItemAttributeBoolean :: Maybe Bool
    xmlItemAttributeBoolean = Maybe Bool
    forall a. Maybe a
    Nothing
      , xmlItemWrappedArray :: Maybe [Int]
    xmlItemWrappedArray = Maybe [Int]
    forall a. Maybe a
    Nothing
      , xmlItemNameString :: Maybe Text
    xmlItemNameString = Maybe Text
    forall a. Maybe a
    Nothing
      , xmlItemNameNumber :: Maybe Double
    xmlItemNameNumber = Maybe Double
    forall a. Maybe a
    Nothing
      , xmlItemNameInteger :: Maybe Int
    xmlItemNameInteger = Maybe Int
    forall a. Maybe a
    Nothing
      , xmlItemNameBoolean :: Maybe Bool
    xmlItemNameBoolean = Maybe Bool
    forall a. Maybe a
    Nothing
      , xmlItemNameArray :: Maybe [Int]
    xmlItemNameArray = Maybe [Int]
    forall a. Maybe a
    Nothing
      , xmlItemNameWrappedArray :: Maybe [Int]
    xmlItemNameWrappedArray = Maybe [Int]
    forall a. Maybe a
    Nothing
      , xmlItemPrefixString :: Maybe Text
    xmlItemPrefixString = Maybe Text
    forall a. Maybe a
    Nothing
      , xmlItemPrefixNumber :: Maybe Double
    xmlItemPrefixNumber = Maybe Double
    forall a. Maybe a
    Nothing
      , xmlItemPrefixInteger :: Maybe Int
    xmlItemPrefixInteger = Maybe Int
    forall a. Maybe a
    Nothing
      , xmlItemPrefixBoolean :: Maybe Bool
    xmlItemPrefixBoolean = Maybe Bool
    forall a. Maybe a
    Nothing
      , xmlItemPrefixArray :: Maybe [Int]
    xmlItemPrefixArray = Maybe [Int]
    forall a. Maybe a
    Nothing
      , xmlItemPrefixWrappedArray :: Maybe [Int]
    xmlItemPrefixWrappedArray = Maybe [Int]
    forall a. Maybe a
    Nothing
      , xmlItemNamespaceString :: Maybe Text
    xmlItemNamespaceString = Maybe Text
    forall a. Maybe a
    Nothing
      , xmlItemNamespaceNumber :: Maybe Double
    xmlItemNamespaceNumber = Maybe Double
    forall a. Maybe a
    Nothing
      , xmlItemNamespaceInteger :: Maybe Int
    xmlItemNamespaceInteger = Maybe Int
    forall a. Maybe a
    Nothing
      , xmlItemNamespaceBoolean :: Maybe Bool
    xmlItemNamespaceBoolean = Maybe Bool
    forall a. Maybe a
    Nothing
      , xmlItemNamespaceArray :: Maybe [Int]
    xmlItemNamespaceArray = Maybe [Int]
    forall a. Maybe a
    Nothing
      , xmlItemNamespaceWrappedArray :: Maybe [Int]
    xmlItemNamespaceWrappedArray = Maybe [Int]
    forall a. Maybe a
    Nothing
      , xmlItemPrefixNsString :: Maybe Text
    xmlItemPrefixNsString = Maybe Text
    forall a. Maybe a
    Nothing
      , xmlItemPrefixNsNumber :: Maybe Double
    xmlItemPrefixNsNumber = Maybe Double
    forall a. Maybe a
    Nothing
      , xmlItemPrefixNsInteger :: Maybe Int
    xmlItemPrefixNsInteger = Maybe Int
    forall a. Maybe a
    Nothing
      , xmlItemPrefixNsBoolean :: Maybe Bool
    xmlItemPrefixNsBoolean = Maybe Bool
    forall a. Maybe a
    Nothing
      , xmlItemPrefixNsArray :: Maybe [Int]
    xmlItemPrefixNsArray = Maybe [Int]
    forall a. Maybe a
    Nothing
      , xmlItemPrefixNsWrappedArray :: Maybe [Int]
    xmlItemPrefixNsWrappedArray = Maybe [Int]
    forall a. Maybe a
    Nothing
      }

    -- * Enums

    -- ** E'ArrayEnum

    -- | Enum of 'Text'
    data E'ArrayEnum
      = E'ArrayEnum'Fish -- ^ @"fish"@
      | E'ArrayEnum'Crab -- ^ @"crab"@
      deriving (Int -> E'ArrayEnum -> ShowS
    [E'ArrayEnum] -> ShowS
    E'ArrayEnum -> [Char]
    (Int -> E'ArrayEnum -> ShowS)
    -> (E'ArrayEnum -> [Char])
    -> ([E'ArrayEnum] -> ShowS)
    -> Show E'ArrayEnum
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'ArrayEnum -> ShowS
    showsPrec :: Int -> E'ArrayEnum -> ShowS
    $cshow :: E'ArrayEnum -> [Char]
    show :: E'ArrayEnum -> [Char]
    $cshowList :: [E'ArrayEnum] -> ShowS
    showList :: [E'ArrayEnum] -> ShowS
    P.Show, E'ArrayEnum -> E'ArrayEnum -> Bool
    (E'ArrayEnum -> E'ArrayEnum -> Bool)
    -> (E'ArrayEnum -> E'ArrayEnum -> Bool) -> Eq E'ArrayEnum
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'ArrayEnum -> E'ArrayEnum -> Bool
    == :: E'ArrayEnum -> E'ArrayEnum -> Bool
    $c/= :: E'ArrayEnum -> E'ArrayEnum -> Bool
    /= :: E'ArrayEnum -> E'ArrayEnum -> Bool
    P.Eq, P.Typeable, Eq E'ArrayEnum
    Eq E'ArrayEnum
    -> (E'ArrayEnum -> E'ArrayEnum -> Ordering)
    -> (E'ArrayEnum -> E'ArrayEnum -> Bool)
    -> (E'ArrayEnum -> E'ArrayEnum -> Bool)
    -> (E'ArrayEnum -> E'ArrayEnum -> Bool)
    -> (E'ArrayEnum -> E'ArrayEnum -> Bool)
    -> (E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum)
    -> (E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum)
    -> Ord E'ArrayEnum
    E'ArrayEnum -> E'ArrayEnum -> Bool
    E'ArrayEnum -> E'ArrayEnum -> Ordering
    E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum
    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
    $ccompare :: E'ArrayEnum -> E'ArrayEnum -> Ordering
    compare :: E'ArrayEnum -> E'ArrayEnum -> Ordering
    $c< :: E'ArrayEnum -> E'ArrayEnum -> Bool
    < :: E'ArrayEnum -> E'ArrayEnum -> Bool
    $c<= :: E'ArrayEnum -> E'ArrayEnum -> Bool
    <= :: E'ArrayEnum -> E'ArrayEnum -> Bool
    $c> :: E'ArrayEnum -> E'ArrayEnum -> Bool
    > :: E'ArrayEnum -> E'ArrayEnum -> Bool
    $c>= :: E'ArrayEnum -> E'ArrayEnum -> Bool
    >= :: E'ArrayEnum -> E'ArrayEnum -> Bool
    $cmax :: E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum
    max :: E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum
    $cmin :: E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum
    min :: E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum
    P.Ord, E'ArrayEnum
    E'ArrayEnum -> E'ArrayEnum -> Bounded E'ArrayEnum
    forall a. a -> a -> Bounded a
    $cminBound :: E'ArrayEnum
    minBound :: E'ArrayEnum
    $cmaxBound :: E'ArrayEnum
    maxBound :: E'ArrayEnum
    P.Bounded, Int -> E'ArrayEnum
    E'ArrayEnum -> Int
    E'ArrayEnum -> [E'ArrayEnum]
    E'ArrayEnum -> E'ArrayEnum
    E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum]
    E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum]
    (E'ArrayEnum -> E'ArrayEnum)
    -> (E'ArrayEnum -> E'ArrayEnum)
    -> (Int -> E'ArrayEnum)
    -> (E'ArrayEnum -> Int)
    -> (E'ArrayEnum -> [E'ArrayEnum])
    -> (E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum])
    -> (E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum])
    -> (E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum])
    -> Enum E'ArrayEnum
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'ArrayEnum -> E'ArrayEnum
    succ :: E'ArrayEnum -> E'ArrayEnum
    $cpred :: E'ArrayEnum -> E'ArrayEnum
    pred :: E'ArrayEnum -> E'ArrayEnum
    $ctoEnum :: Int -> E'ArrayEnum
    toEnum :: Int -> E'ArrayEnum
    $cfromEnum :: E'ArrayEnum -> Int
    fromEnum :: E'ArrayEnum -> Int
    $cenumFrom :: E'ArrayEnum -> [E'ArrayEnum]
    enumFrom :: E'ArrayEnum -> [E'ArrayEnum]
    $cenumFromThen :: E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum]
    enumFromThen :: E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum]
    $cenumFromTo :: E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum]
    enumFromTo :: E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum]
    $cenumFromThenTo :: E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum]
    enumFromThenTo :: E'ArrayEnum -> E'ArrayEnum -> E'ArrayEnum -> [E'ArrayEnum]
    P.Enum)

    instance A.ToJSON E'ArrayEnum where toJSON :: E'ArrayEnum -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value) -> (E'ArrayEnum -> Text) -> E'ArrayEnum -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'ArrayEnum -> Text
    fromE'ArrayEnum
    instance A.FromJSON E'ArrayEnum where parseJSON :: Value -> Parser E'ArrayEnum
    parseJSON Value
    o = ([Char] -> Parser E'ArrayEnum)
    -> (E'ArrayEnum -> Parser E'ArrayEnum)
    -> Either [Char] E'ArrayEnum
    -> Parser E'ArrayEnum
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'ArrayEnum
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'ArrayEnum -> Parser E'ArrayEnum
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'ArrayEnum -> Parser E'ArrayEnum)
    -> (E'ArrayEnum -> E'ArrayEnum)
    -> E'ArrayEnum
    -> Parser E'ArrayEnum
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'ArrayEnum -> E'ArrayEnum
    forall a. a -> a
    P.id) (Either [Char] E'ArrayEnum -> Parser E'ArrayEnum)
    -> (Text -> Either [Char] E'ArrayEnum)
    -> Text
    -> Parser E'ArrayEnum
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'ArrayEnum
    toE'ArrayEnum (Text -> Parser E'ArrayEnum) -> Parser Text -> Parser E'ArrayEnum
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'ArrayEnum where toQueryParam :: E'ArrayEnum -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text) -> (E'ArrayEnum -> Text) -> E'ArrayEnum -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'ArrayEnum -> Text
    fromE'ArrayEnum
    instance WH.FromHttpApiData E'ArrayEnum where parseQueryParam :: Text -> Either Text E'ArrayEnum
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text E'ArrayEnum) -> Either Text E'ArrayEnum
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] E'ArrayEnum -> Either Text E'ArrayEnum
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'ArrayEnum -> Either Text E'ArrayEnum)
    -> (Text -> Either [Char] E'ArrayEnum)
    -> Text
    -> Either Text E'ArrayEnum
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'ArrayEnum
    toE'ArrayEnum
    instance MimeRender MimeMultipartFormData E'ArrayEnum where mimeRender :: Proxy MimeMultipartFormData -> E'ArrayEnum -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'ArrayEnum -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'ArrayEnum' enum
    fromE'ArrayEnum :: E'ArrayEnum -> Text
    fromE'ArrayEnum :: E'ArrayEnum -> Text
    fromE'ArrayEnum = \case
      E'ArrayEnum
    E'ArrayEnum'Fish -> Text
    "fish"
      E'ArrayEnum
    E'ArrayEnum'Crab -> Text
    "crab"

    -- | parse 'E'ArrayEnum' enum
    toE'ArrayEnum :: Text -> P.Either String E'ArrayEnum
    toE'ArrayEnum :: Text -> Either [Char] E'ArrayEnum
    toE'ArrayEnum = \case
      Text
    "fish" -> E'ArrayEnum -> Either [Char] E'ArrayEnum
    forall a b. b -> Either a b
    P.Right E'ArrayEnum
    E'ArrayEnum'Fish
      Text
    "crab" -> E'ArrayEnum -> Either [Char] E'ArrayEnum
    forall a b. b -> Either a b
    P.Right E'ArrayEnum
    E'ArrayEnum'Crab
      Text
    s -> [Char] -> Either [Char] E'ArrayEnum
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'ArrayEnum)
    -> [Char] -> Either [Char] E'ArrayEnum
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'ArrayEnum: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- ** E'EnumFormString

    -- | Enum of 'Text' .
    -- Form parameter enum test (string)
    data E'EnumFormString
      = E'EnumFormString'_abc -- ^ @"_abc"@
      | E'EnumFormString'_efg -- ^ @"-efg"@
      | E'EnumFormString'_xyz -- ^ @"(xyz)"@
      deriving (Int -> E'EnumFormString -> ShowS
    [E'EnumFormString] -> ShowS
    E'EnumFormString -> [Char]
    (Int -> E'EnumFormString -> ShowS)
    -> (E'EnumFormString -> [Char])
    -> ([E'EnumFormString] -> ShowS)
    -> Show E'EnumFormString
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'EnumFormString -> ShowS
    showsPrec :: Int -> E'EnumFormString -> ShowS
    $cshow :: E'EnumFormString -> [Char]
    show :: E'EnumFormString -> [Char]
    $cshowList :: [E'EnumFormString] -> ShowS
    showList :: [E'EnumFormString] -> ShowS
    P.Show, E'EnumFormString -> E'EnumFormString -> Bool
    (E'EnumFormString -> E'EnumFormString -> Bool)
    -> (E'EnumFormString -> E'EnumFormString -> Bool)
    -> Eq E'EnumFormString
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'EnumFormString -> E'EnumFormString -> Bool
    == :: E'EnumFormString -> E'EnumFormString -> Bool
    $c/= :: E'EnumFormString -> E'EnumFormString -> Bool
    /= :: E'EnumFormString -> E'EnumFormString -> Bool
    P.Eq, P.Typeable, Eq E'EnumFormString
    Eq E'EnumFormString
    -> (E'EnumFormString -> E'EnumFormString -> Ordering)
    -> (E'EnumFormString -> E'EnumFormString -> Bool)
    -> (E'EnumFormString -> E'EnumFormString -> Bool)
    -> (E'EnumFormString -> E'EnumFormString -> Bool)
    -> (E'EnumFormString -> E'EnumFormString -> Bool)
    -> (E'EnumFormString -> E'EnumFormString -> E'EnumFormString)
    -> (E'EnumFormString -> E'EnumFormString -> E'EnumFormString)
    -> Ord E'EnumFormString
    E'EnumFormString -> E'EnumFormString -> Bool
    E'EnumFormString -> E'EnumFormString -> Ordering
    E'EnumFormString -> E'EnumFormString -> E'EnumFormString
    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
    $ccompare :: E'EnumFormString -> E'EnumFormString -> Ordering
    compare :: E'EnumFormString -> E'EnumFormString -> Ordering
    $c< :: E'EnumFormString -> E'EnumFormString -> Bool
    < :: E'EnumFormString -> E'EnumFormString -> Bool
    $c<= :: E'EnumFormString -> E'EnumFormString -> Bool
    <= :: E'EnumFormString -> E'EnumFormString -> Bool
    $c> :: E'EnumFormString -> E'EnumFormString -> Bool
    > :: E'EnumFormString -> E'EnumFormString -> Bool
    $c>= :: E'EnumFormString -> E'EnumFormString -> Bool
    >= :: E'EnumFormString -> E'EnumFormString -> Bool
    $cmax :: E'EnumFormString -> E'EnumFormString -> E'EnumFormString
    max :: E'EnumFormString -> E'EnumFormString -> E'EnumFormString
    $cmin :: E'EnumFormString -> E'EnumFormString -> E'EnumFormString
    min :: E'EnumFormString -> E'EnumFormString -> E'EnumFormString
    P.Ord, E'EnumFormString
    E'EnumFormString -> E'EnumFormString -> Bounded E'EnumFormString
    forall a. a -> a -> Bounded a
    $cminBound :: E'EnumFormString
    minBound :: E'EnumFormString
    $cmaxBound :: E'EnumFormString
    maxBound :: E'EnumFormString
    P.Bounded, Int -> E'EnumFormString
    E'EnumFormString -> Int
    E'EnumFormString -> [E'EnumFormString]
    E'EnumFormString -> E'EnumFormString
    E'EnumFormString -> E'EnumFormString -> [E'EnumFormString]
    E'EnumFormString
    -> E'EnumFormString -> E'EnumFormString -> [E'EnumFormString]
    (E'EnumFormString -> E'EnumFormString)
    -> (E'EnumFormString -> E'EnumFormString)
    -> (Int -> E'EnumFormString)
    -> (E'EnumFormString -> Int)
    -> (E'EnumFormString -> [E'EnumFormString])
    -> (E'EnumFormString -> E'EnumFormString -> [E'EnumFormString])
    -> (E'EnumFormString -> E'EnumFormString -> [E'EnumFormString])
    -> (E'EnumFormString
        -> E'EnumFormString -> E'EnumFormString -> [E'EnumFormString])
    -> Enum E'EnumFormString
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'EnumFormString -> E'EnumFormString
    succ :: E'EnumFormString -> E'EnumFormString
    $cpred :: E'EnumFormString -> E'EnumFormString
    pred :: E'EnumFormString -> E'EnumFormString
    $ctoEnum :: Int -> E'EnumFormString
    toEnum :: Int -> E'EnumFormString
    $cfromEnum :: E'EnumFormString -> Int
    fromEnum :: E'EnumFormString -> Int
    $cenumFrom :: E'EnumFormString -> [E'EnumFormString]
    enumFrom :: E'EnumFormString -> [E'EnumFormString]
    $cenumFromThen :: E'EnumFormString -> E'EnumFormString -> [E'EnumFormString]
    enumFromThen :: E'EnumFormString -> E'EnumFormString -> [E'EnumFormString]
    $cenumFromTo :: E'EnumFormString -> E'EnumFormString -> [E'EnumFormString]
    enumFromTo :: E'EnumFormString -> E'EnumFormString -> [E'EnumFormString]
    $cenumFromThenTo :: E'EnumFormString
    -> E'EnumFormString -> E'EnumFormString -> [E'EnumFormString]
    enumFromThenTo :: E'EnumFormString
    -> E'EnumFormString -> E'EnumFormString -> [E'EnumFormString]
    P.Enum)

    instance A.ToJSON E'EnumFormString where toJSON :: E'EnumFormString -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value)
    -> (E'EnumFormString -> Text) -> E'EnumFormString -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumFormString -> Text
    fromE'EnumFormString
    instance A.FromJSON E'EnumFormString where parseJSON :: Value -> Parser E'EnumFormString
    parseJSON Value
    o = ([Char] -> Parser E'EnumFormString)
    -> (E'EnumFormString -> Parser E'EnumFormString)
    -> Either [Char] E'EnumFormString
    -> Parser E'EnumFormString
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'EnumFormString
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'EnumFormString -> Parser E'EnumFormString
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'EnumFormString -> Parser E'EnumFormString)
    -> (E'EnumFormString -> E'EnumFormString)
    -> E'EnumFormString
    -> Parser E'EnumFormString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumFormString -> E'EnumFormString
    forall a. a -> a
    P.id) (Either [Char] E'EnumFormString -> Parser E'EnumFormString)
    -> (Text -> Either [Char] E'EnumFormString)
    -> Text
    -> Parser E'EnumFormString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'EnumFormString
    toE'EnumFormString (Text -> Parser E'EnumFormString)
    -> Parser Text -> Parser E'EnumFormString
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'EnumFormString where toQueryParam :: E'EnumFormString -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text)
    -> (E'EnumFormString -> Text) -> E'EnumFormString -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumFormString -> Text
    fromE'EnumFormString
    instance WH.FromHttpApiData E'EnumFormString where parseQueryParam :: Text -> Either Text E'EnumFormString
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text E'EnumFormString)
    -> Either Text E'EnumFormString
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] E'EnumFormString -> Either Text E'EnumFormString
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'EnumFormString -> Either Text E'EnumFormString)
    -> (Text -> Either [Char] E'EnumFormString)
    -> Text
    -> Either Text E'EnumFormString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'EnumFormString
    toE'EnumFormString
    instance MimeRender MimeMultipartFormData E'EnumFormString where mimeRender :: Proxy MimeMultipartFormData -> E'EnumFormString -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'EnumFormString -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'EnumFormString' enum
    fromE'EnumFormString :: E'EnumFormString -> Text
    fromE'EnumFormString :: E'EnumFormString -> Text
    fromE'EnumFormString = \case
      E'EnumFormString
    E'EnumFormString'_abc -> Text
    "_abc"
      E'EnumFormString
    E'EnumFormString'_efg -> Text
    "-efg"
      E'EnumFormString
    E'EnumFormString'_xyz -> Text
    "(xyz)"

    -- | parse 'E'EnumFormString' enum
    toE'EnumFormString :: Text -> P.Either String E'EnumFormString
    toE'EnumFormString :: Text -> Either [Char] E'EnumFormString
    toE'EnumFormString = \case
      Text
    "_abc" -> E'EnumFormString -> Either [Char] E'EnumFormString
    forall a b. b -> Either a b
    P.Right E'EnumFormString
    E'EnumFormString'_abc
      Text
    "-efg" -> E'EnumFormString -> Either [Char] E'EnumFormString
    forall a b. b -> Either a b
    P.Right E'EnumFormString
    E'EnumFormString'_efg
      Text
    "(xyz)" -> E'EnumFormString -> Either [Char] E'EnumFormString
    forall a b. b -> Either a b
    P.Right E'EnumFormString
    E'EnumFormString'_xyz
      Text
    s -> [Char] -> Either [Char] E'EnumFormString
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'EnumFormString)
    -> [Char] -> Either [Char] E'EnumFormString
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'EnumFormString: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- ** E'EnumFormStringArray

    -- | Enum of 'Text'
    data E'EnumFormStringArray
      = E'EnumFormStringArray'GreaterThan -- ^ @">"@
      | E'EnumFormStringArray'Dollar -- ^ @"$"@
      deriving (Int -> E'EnumFormStringArray -> ShowS
    [E'EnumFormStringArray] -> ShowS
    E'EnumFormStringArray -> [Char]
    (Int -> E'EnumFormStringArray -> ShowS)
    -> (E'EnumFormStringArray -> [Char])
    -> ([E'EnumFormStringArray] -> ShowS)
    -> Show E'EnumFormStringArray
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'EnumFormStringArray -> ShowS
    showsPrec :: Int -> E'EnumFormStringArray -> ShowS
    $cshow :: E'EnumFormStringArray -> [Char]
    show :: E'EnumFormStringArray -> [Char]
    $cshowList :: [E'EnumFormStringArray] -> ShowS
    showList :: [E'EnumFormStringArray] -> ShowS
    P.Show, E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    (E'EnumFormStringArray -> E'EnumFormStringArray -> Bool)
    -> (E'EnumFormStringArray -> E'EnumFormStringArray -> Bool)
    -> Eq E'EnumFormStringArray
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    == :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    $c/= :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    /= :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    P.Eq, P.Typeable, Eq E'EnumFormStringArray
    Eq E'EnumFormStringArray
    -> (E'EnumFormStringArray -> E'EnumFormStringArray -> Ordering)
    -> (E'EnumFormStringArray -> E'EnumFormStringArray -> Bool)
    -> (E'EnumFormStringArray -> E'EnumFormStringArray -> Bool)
    -> (E'EnumFormStringArray -> E'EnumFormStringArray -> Bool)
    -> (E'EnumFormStringArray -> E'EnumFormStringArray -> Bool)
    -> (E'EnumFormStringArray
        -> E'EnumFormStringArray -> E'EnumFormStringArray)
    -> (E'EnumFormStringArray
        -> E'EnumFormStringArray -> E'EnumFormStringArray)
    -> Ord E'EnumFormStringArray
    E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    E'EnumFormStringArray -> E'EnumFormStringArray -> Ordering
    E'EnumFormStringArray
    -> E'EnumFormStringArray -> E'EnumFormStringArray
    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
    $ccompare :: E'EnumFormStringArray -> E'EnumFormStringArray -> Ordering
    compare :: E'EnumFormStringArray -> E'EnumFormStringArray -> Ordering
    $c< :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    < :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    $c<= :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    <= :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    $c> :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    > :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    $c>= :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    >= :: E'EnumFormStringArray -> E'EnumFormStringArray -> Bool
    $cmax :: E'EnumFormStringArray
    -> E'EnumFormStringArray -> E'EnumFormStringArray
    max :: E'EnumFormStringArray
    -> E'EnumFormStringArray -> E'EnumFormStringArray
    $cmin :: E'EnumFormStringArray
    -> E'EnumFormStringArray -> E'EnumFormStringArray
    min :: E'EnumFormStringArray
    -> E'EnumFormStringArray -> E'EnumFormStringArray
    P.Ord, E'EnumFormStringArray
    E'EnumFormStringArray
    -> E'EnumFormStringArray -> Bounded E'EnumFormStringArray
    forall a. a -> a -> Bounded a
    $cminBound :: E'EnumFormStringArray
    minBound :: E'EnumFormStringArray
    $cmaxBound :: E'EnumFormStringArray
    maxBound :: E'EnumFormStringArray
    P.Bounded, Int -> E'EnumFormStringArray
    E'EnumFormStringArray -> Int
    E'EnumFormStringArray -> [E'EnumFormStringArray]
    E'EnumFormStringArray -> E'EnumFormStringArray
    E'EnumFormStringArray
    -> E'EnumFormStringArray -> [E'EnumFormStringArray]
    E'EnumFormStringArray
    -> E'EnumFormStringArray
    -> E'EnumFormStringArray
    -> [E'EnumFormStringArray]
    (E'EnumFormStringArray -> E'EnumFormStringArray)
    -> (E'EnumFormStringArray -> E'EnumFormStringArray)
    -> (Int -> E'EnumFormStringArray)
    -> (E'EnumFormStringArray -> Int)
    -> (E'EnumFormStringArray -> [E'EnumFormStringArray])
    -> (E'EnumFormStringArray
        -> E'EnumFormStringArray -> [E'EnumFormStringArray])
    -> (E'EnumFormStringArray
        -> E'EnumFormStringArray -> [E'EnumFormStringArray])
    -> (E'EnumFormStringArray
        -> E'EnumFormStringArray
        -> E'EnumFormStringArray
        -> [E'EnumFormStringArray])
    -> Enum E'EnumFormStringArray
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'EnumFormStringArray -> E'EnumFormStringArray
    succ :: E'EnumFormStringArray -> E'EnumFormStringArray
    $cpred :: E'EnumFormStringArray -> E'EnumFormStringArray
    pred :: E'EnumFormStringArray -> E'EnumFormStringArray
    $ctoEnum :: Int -> E'EnumFormStringArray
    toEnum :: Int -> E'EnumFormStringArray
    $cfromEnum :: E'EnumFormStringArray -> Int
    fromEnum :: E'EnumFormStringArray -> Int
    $cenumFrom :: E'EnumFormStringArray -> [E'EnumFormStringArray]
    enumFrom :: E'EnumFormStringArray -> [E'EnumFormStringArray]
    $cenumFromThen :: E'EnumFormStringArray
    -> E'EnumFormStringArray -> [E'EnumFormStringArray]
    enumFromThen :: E'EnumFormStringArray
    -> E'EnumFormStringArray -> [E'EnumFormStringArray]
    $cenumFromTo :: E'EnumFormStringArray
    -> E'EnumFormStringArray -> [E'EnumFormStringArray]
    enumFromTo :: E'EnumFormStringArray
    -> E'EnumFormStringArray -> [E'EnumFormStringArray]
    $cenumFromThenTo :: E'EnumFormStringArray
    -> E'EnumFormStringArray
    -> E'EnumFormStringArray
    -> [E'EnumFormStringArray]
    enumFromThenTo :: E'EnumFormStringArray
    -> E'EnumFormStringArray
    -> E'EnumFormStringArray
    -> [E'EnumFormStringArray]
    P.Enum)

    instance A.ToJSON E'EnumFormStringArray where toJSON :: E'EnumFormStringArray -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value)
    -> (E'EnumFormStringArray -> Text)
    -> E'EnumFormStringArray
    -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumFormStringArray -> Text
    fromE'EnumFormStringArray
    instance A.FromJSON E'EnumFormStringArray where parseJSON :: Value -> Parser E'EnumFormStringArray
    parseJSON Value
    o = ([Char] -> Parser E'EnumFormStringArray)
    -> (E'EnumFormStringArray -> Parser E'EnumFormStringArray)
    -> Either [Char] E'EnumFormStringArray
    -> Parser E'EnumFormStringArray
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'EnumFormStringArray
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'EnumFormStringArray -> Parser E'EnumFormStringArray
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'EnumFormStringArray -> Parser E'EnumFormStringArray)
    -> (E'EnumFormStringArray -> E'EnumFormStringArray)
    -> E'EnumFormStringArray
    -> Parser E'EnumFormStringArray
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumFormStringArray -> E'EnumFormStringArray
    forall a. a -> a
    P.id) (Either [Char] E'EnumFormStringArray
     -> Parser E'EnumFormStringArray)
    -> (Text -> Either [Char] E'EnumFormStringArray)
    -> Text
    -> Parser E'EnumFormStringArray
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'EnumFormStringArray
    toE'EnumFormStringArray (Text -> Parser E'EnumFormStringArray)
    -> Parser Text -> Parser E'EnumFormStringArray
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'EnumFormStringArray where toQueryParam :: E'EnumFormStringArray -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text)
    -> (E'EnumFormStringArray -> Text) -> E'EnumFormStringArray -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumFormStringArray -> Text
    fromE'EnumFormStringArray
    instance WH.FromHttpApiData E'EnumFormStringArray where parseQueryParam :: Text -> Either Text E'EnumFormStringArray
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text E'EnumFormStringArray)
    -> Either Text E'EnumFormStringArray
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] E'EnumFormStringArray
    -> Either Text E'EnumFormStringArray
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'EnumFormStringArray
     -> Either Text E'EnumFormStringArray)
    -> (Text -> Either [Char] E'EnumFormStringArray)
    -> Text
    -> Either Text E'EnumFormStringArray
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'EnumFormStringArray
    toE'EnumFormStringArray
    instance MimeRender MimeMultipartFormData E'EnumFormStringArray where mimeRender :: Proxy MimeMultipartFormData -> E'EnumFormStringArray -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'EnumFormStringArray -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'EnumFormStringArray' enum
    fromE'EnumFormStringArray :: E'EnumFormStringArray -> Text
    fromE'EnumFormStringArray :: E'EnumFormStringArray -> Text
    fromE'EnumFormStringArray = \case
      E'EnumFormStringArray
    E'EnumFormStringArray'GreaterThan -> Text
    ">"
      E'EnumFormStringArray
    E'EnumFormStringArray'Dollar -> Text
    "$"

    -- | parse 'E'EnumFormStringArray' enum
    toE'EnumFormStringArray :: Text -> P.Either String E'EnumFormStringArray
    toE'EnumFormStringArray :: Text -> Either [Char] E'EnumFormStringArray
    toE'EnumFormStringArray = \case
      Text
    ">" -> E'EnumFormStringArray -> Either [Char] E'EnumFormStringArray
    forall a b. b -> Either a b
    P.Right E'EnumFormStringArray
    E'EnumFormStringArray'GreaterThan
      Text
    "$" -> E'EnumFormStringArray -> Either [Char] E'EnumFormStringArray
    forall a b. b -> Either a b
    P.Right E'EnumFormStringArray
    E'EnumFormStringArray'Dollar
      Text
    s -> [Char] -> Either [Char] E'EnumFormStringArray
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'EnumFormStringArray)
    -> [Char] -> Either [Char] E'EnumFormStringArray
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'EnumFormStringArray: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- ** E'EnumInteger

    -- | Enum of 'Int'
    data E'EnumInteger
      = E'EnumInteger'Num1 -- ^ @1@
      | E'EnumInteger'NumMinus_1 -- ^ @-1@
      deriving (Int -> E'EnumInteger -> ShowS
    [E'EnumInteger] -> ShowS
    E'EnumInteger -> [Char]
    (Int -> E'EnumInteger -> ShowS)
    -> (E'EnumInteger -> [Char])
    -> ([E'EnumInteger] -> ShowS)
    -> Show E'EnumInteger
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'EnumInteger -> ShowS
    showsPrec :: Int -> E'EnumInteger -> ShowS
    $cshow :: E'EnumInteger -> [Char]
    show :: E'EnumInteger -> [Char]
    $cshowList :: [E'EnumInteger] -> ShowS
    showList :: [E'EnumInteger] -> ShowS
    P.Show, E'EnumInteger -> E'EnumInteger -> Bool
    (E'EnumInteger -> E'EnumInteger -> Bool)
    -> (E'EnumInteger -> E'EnumInteger -> Bool) -> Eq E'EnumInteger
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'EnumInteger -> E'EnumInteger -> Bool
    == :: E'EnumInteger -> E'EnumInteger -> Bool
    $c/= :: E'EnumInteger -> E'EnumInteger -> Bool
    /= :: E'EnumInteger -> E'EnumInteger -> Bool
    P.Eq, P.Typeable, Eq E'EnumInteger
    Eq E'EnumInteger
    -> (E'EnumInteger -> E'EnumInteger -> Ordering)
    -> (E'EnumInteger -> E'EnumInteger -> Bool)
    -> (E'EnumInteger -> E'EnumInteger -> Bool)
    -> (E'EnumInteger -> E'EnumInteger -> Bool)
    -> (E'EnumInteger -> E'EnumInteger -> Bool)
    -> (E'EnumInteger -> E'EnumInteger -> E'EnumInteger)
    -> (E'EnumInteger -> E'EnumInteger -> E'EnumInteger)
    -> Ord E'EnumInteger
    E'EnumInteger -> E'EnumInteger -> Bool
    E'EnumInteger -> E'EnumInteger -> Ordering
    E'EnumInteger -> E'EnumInteger -> E'EnumInteger
    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
    $ccompare :: E'EnumInteger -> E'EnumInteger -> Ordering
    compare :: E'EnumInteger -> E'EnumInteger -> Ordering
    $c< :: E'EnumInteger -> E'EnumInteger -> Bool
    < :: E'EnumInteger -> E'EnumInteger -> Bool
    $c<= :: E'EnumInteger -> E'EnumInteger -> Bool
    <= :: E'EnumInteger -> E'EnumInteger -> Bool
    $c> :: E'EnumInteger -> E'EnumInteger -> Bool
    > :: E'EnumInteger -> E'EnumInteger -> Bool
    $c>= :: E'EnumInteger -> E'EnumInteger -> Bool
    >= :: E'EnumInteger -> E'EnumInteger -> Bool
    $cmax :: E'EnumInteger -> E'EnumInteger -> E'EnumInteger
    max :: E'EnumInteger -> E'EnumInteger -> E'EnumInteger
    $cmin :: E'EnumInteger -> E'EnumInteger -> E'EnumInteger
    min :: E'EnumInteger -> E'EnumInteger -> E'EnumInteger
    P.Ord, E'EnumInteger
    E'EnumInteger -> E'EnumInteger -> Bounded E'EnumInteger
    forall a. a -> a -> Bounded a
    $cminBound :: E'EnumInteger
    minBound :: E'EnumInteger
    $cmaxBound :: E'EnumInteger
    maxBound :: E'EnumInteger
    P.Bounded, Int -> E'EnumInteger
    E'EnumInteger -> Int
    E'EnumInteger -> [E'EnumInteger]
    E'EnumInteger -> E'EnumInteger
    E'EnumInteger -> E'EnumInteger -> [E'EnumInteger]
    E'EnumInteger -> E'EnumInteger -> E'EnumInteger -> [E'EnumInteger]
    (E'EnumInteger -> E'EnumInteger)
    -> (E'EnumInteger -> E'EnumInteger)
    -> (Int -> E'EnumInteger)
    -> (E'EnumInteger -> Int)
    -> (E'EnumInteger -> [E'EnumInteger])
    -> (E'EnumInteger -> E'EnumInteger -> [E'EnumInteger])
    -> (E'EnumInteger -> E'EnumInteger -> [E'EnumInteger])
    -> (E'EnumInteger
        -> E'EnumInteger -> E'EnumInteger -> [E'EnumInteger])
    -> Enum E'EnumInteger
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'EnumInteger -> E'EnumInteger
    succ :: E'EnumInteger -> E'EnumInteger
    $cpred :: E'EnumInteger -> E'EnumInteger
    pred :: E'EnumInteger -> E'EnumInteger
    $ctoEnum :: Int -> E'EnumInteger
    toEnum :: Int -> E'EnumInteger
    $cfromEnum :: E'EnumInteger -> Int
    fromEnum :: E'EnumInteger -> Int
    $cenumFrom :: E'EnumInteger -> [E'EnumInteger]
    enumFrom :: E'EnumInteger -> [E'EnumInteger]
    $cenumFromThen :: E'EnumInteger -> E'EnumInteger -> [E'EnumInteger]
    enumFromThen :: E'EnumInteger -> E'EnumInteger -> [E'EnumInteger]
    $cenumFromTo :: E'EnumInteger -> E'EnumInteger -> [E'EnumInteger]
    enumFromTo :: E'EnumInteger -> E'EnumInteger -> [E'EnumInteger]
    $cenumFromThenTo :: E'EnumInteger -> E'EnumInteger -> E'EnumInteger -> [E'EnumInteger]
    enumFromThenTo :: E'EnumInteger -> E'EnumInteger -> E'EnumInteger -> [E'EnumInteger]
    P.Enum)

    instance A.ToJSON E'EnumInteger where toJSON :: E'EnumInteger -> Value
    toJSON = Int -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Int -> Value) -> (E'EnumInteger -> Int) -> E'EnumInteger -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumInteger -> Int
    fromE'EnumInteger
    instance A.FromJSON E'EnumInteger where parseJSON :: Value -> Parser E'EnumInteger
    parseJSON Value
    o = ([Char] -> Parser E'EnumInteger)
    -> (E'EnumInteger -> Parser E'EnumInteger)
    -> Either [Char] E'EnumInteger
    -> Parser E'EnumInteger
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'EnumInteger
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'EnumInteger -> Parser E'EnumInteger
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'EnumInteger -> Parser E'EnumInteger)
    -> (E'EnumInteger -> E'EnumInteger)
    -> E'EnumInteger
    -> Parser E'EnumInteger
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumInteger -> E'EnumInteger
    forall a. a -> a
    P.id) (Either [Char] E'EnumInteger -> Parser E'EnumInteger)
    -> (Int -> Either [Char] E'EnumInteger)
    -> Int
    -> Parser E'EnumInteger
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Either [Char] E'EnumInteger
    toE'EnumInteger (Int -> Parser E'EnumInteger) -> Parser Int -> Parser E'EnumInteger
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Int
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'EnumInteger where toQueryParam :: E'EnumInteger -> Text
    toQueryParam = Int -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Int -> Text) -> (E'EnumInteger -> Int) -> E'EnumInteger -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumInteger -> Int
    fromE'EnumInteger
    instance WH.FromHttpApiData E'EnumInteger where parseQueryParam :: Text -> Either Text E'EnumInteger
    parseQueryParam Text
    o = Text -> Either Text Int
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Int
    -> (Int -> Either Text E'EnumInteger) -> Either Text E'EnumInteger
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] E'EnumInteger -> Either Text E'EnumInteger
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'EnumInteger -> Either Text E'EnumInteger)
    -> (Int -> Either [Char] E'EnumInteger)
    -> Int
    -> Either Text E'EnumInteger
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Either [Char] E'EnumInteger
    toE'EnumInteger
    instance MimeRender MimeMultipartFormData E'EnumInteger where mimeRender :: Proxy MimeMultipartFormData -> E'EnumInteger -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'EnumInteger -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'EnumInteger' enum
    fromE'EnumInteger :: E'EnumInteger -> Int
    fromE'EnumInteger :: E'EnumInteger -> Int
    fromE'EnumInteger = \case
      E'EnumInteger
    E'EnumInteger'Num1 -> Int
    1
      E'EnumInteger
    E'EnumInteger'NumMinus_1 -> -Int
    1

    -- | parse 'E'EnumInteger' enum
    toE'EnumInteger :: Int -> P.Either String E'EnumInteger
    toE'EnumInteger :: Int -> Either [Char] E'EnumInteger
    toE'EnumInteger = \case
      Int
    1 -> E'EnumInteger -> Either [Char] E'EnumInteger
    forall a b. b -> Either a b
    P.Right E'EnumInteger
    E'EnumInteger'Num1
      -1 -> E'EnumInteger -> Either [Char] E'EnumInteger
    forall a b. b -> Either a b
    P.Right E'EnumInteger
    E'EnumInteger'NumMinus_1
      Int
    s -> [Char] -> Either [Char] E'EnumInteger
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'EnumInteger)
    -> [Char] -> Either [Char] E'EnumInteger
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'EnumInteger: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Int -> [Char]
    forall a. Show a => a -> [Char]
    P.show Int
    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 (Int -> E'EnumNumber -> ShowS
    [E'EnumNumber] -> ShowS
    E'EnumNumber -> [Char]
    (Int -> E'EnumNumber -> ShowS)
    -> (E'EnumNumber -> [Char])
    -> ([E'EnumNumber] -> ShowS)
    -> Show E'EnumNumber
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'EnumNumber -> ShowS
    showsPrec :: Int -> E'EnumNumber -> ShowS
    $cshow :: E'EnumNumber -> [Char]
    show :: E'EnumNumber -> [Char]
    $cshowList :: [E'EnumNumber] -> ShowS
    showList :: [E'EnumNumber] -> ShowS
    P.Show, E'EnumNumber -> E'EnumNumber -> Bool
    (E'EnumNumber -> E'EnumNumber -> Bool)
    -> (E'EnumNumber -> E'EnumNumber -> Bool) -> Eq E'EnumNumber
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'EnumNumber -> E'EnumNumber -> Bool
    == :: E'EnumNumber -> E'EnumNumber -> Bool
    $c/= :: E'EnumNumber -> E'EnumNumber -> Bool
    /= :: E'EnumNumber -> E'EnumNumber -> Bool
    P.Eq, P.Typeable, Eq E'EnumNumber
    Eq E'EnumNumber
    -> (E'EnumNumber -> E'EnumNumber -> Ordering)
    -> (E'EnumNumber -> E'EnumNumber -> Bool)
    -> (E'EnumNumber -> E'EnumNumber -> Bool)
    -> (E'EnumNumber -> E'EnumNumber -> Bool)
    -> (E'EnumNumber -> E'EnumNumber -> Bool)
    -> (E'EnumNumber -> E'EnumNumber -> E'EnumNumber)
    -> (E'EnumNumber -> E'EnumNumber -> E'EnumNumber)
    -> Ord E'EnumNumber
    E'EnumNumber -> E'EnumNumber -> Bool
    E'EnumNumber -> E'EnumNumber -> Ordering
    E'EnumNumber -> E'EnumNumber -> E'EnumNumber
    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
    $ccompare :: E'EnumNumber -> E'EnumNumber -> Ordering
    compare :: E'EnumNumber -> E'EnumNumber -> Ordering
    $c< :: E'EnumNumber -> E'EnumNumber -> Bool
    < :: E'EnumNumber -> E'EnumNumber -> Bool
    $c<= :: E'EnumNumber -> E'EnumNumber -> Bool
    <= :: E'EnumNumber -> E'EnumNumber -> Bool
    $c> :: E'EnumNumber -> E'EnumNumber -> Bool
    > :: E'EnumNumber -> E'EnumNumber -> Bool
    $c>= :: E'EnumNumber -> E'EnumNumber -> Bool
    >= :: E'EnumNumber -> E'EnumNumber -> Bool
    $cmax :: E'EnumNumber -> E'EnumNumber -> E'EnumNumber
    max :: E'EnumNumber -> E'EnumNumber -> E'EnumNumber
    $cmin :: E'EnumNumber -> E'EnumNumber -> E'EnumNumber
    min :: E'EnumNumber -> E'EnumNumber -> E'EnumNumber
    P.Ord, E'EnumNumber
    E'EnumNumber -> E'EnumNumber -> Bounded E'EnumNumber
    forall a. a -> a -> Bounded a
    $cminBound :: E'EnumNumber
    minBound :: E'EnumNumber
    $cmaxBound :: E'EnumNumber
    maxBound :: E'EnumNumber
    P.Bounded, Int -> E'EnumNumber
    E'EnumNumber -> Int
    E'EnumNumber -> [E'EnumNumber]
    E'EnumNumber -> E'EnumNumber
    E'EnumNumber -> E'EnumNumber -> [E'EnumNumber]
    E'EnumNumber -> E'EnumNumber -> E'EnumNumber -> [E'EnumNumber]
    (E'EnumNumber -> E'EnumNumber)
    -> (E'EnumNumber -> E'EnumNumber)
    -> (Int -> E'EnumNumber)
    -> (E'EnumNumber -> Int)
    -> (E'EnumNumber -> [E'EnumNumber])
    -> (E'EnumNumber -> E'EnumNumber -> [E'EnumNumber])
    -> (E'EnumNumber -> E'EnumNumber -> [E'EnumNumber])
    -> (E'EnumNumber -> E'EnumNumber -> E'EnumNumber -> [E'EnumNumber])
    -> Enum E'EnumNumber
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'EnumNumber -> E'EnumNumber
    succ :: E'EnumNumber -> E'EnumNumber
    $cpred :: E'EnumNumber -> E'EnumNumber
    pred :: E'EnumNumber -> E'EnumNumber
    $ctoEnum :: Int -> E'EnumNumber
    toEnum :: Int -> E'EnumNumber
    $cfromEnum :: E'EnumNumber -> Int
    fromEnum :: E'EnumNumber -> Int
    $cenumFrom :: E'EnumNumber -> [E'EnumNumber]
    enumFrom :: E'EnumNumber -> [E'EnumNumber]
    $cenumFromThen :: E'EnumNumber -> E'EnumNumber -> [E'EnumNumber]
    enumFromThen :: E'EnumNumber -> E'EnumNumber -> [E'EnumNumber]
    $cenumFromTo :: E'EnumNumber -> E'EnumNumber -> [E'EnumNumber]
    enumFromTo :: E'EnumNumber -> E'EnumNumber -> [E'EnumNumber]
    $cenumFromThenTo :: E'EnumNumber -> E'EnumNumber -> E'EnumNumber -> [E'EnumNumber]
    enumFromThenTo :: E'EnumNumber -> E'EnumNumber -> E'EnumNumber -> [E'EnumNumber]
    P.Enum)

    instance A.ToJSON E'EnumNumber where toJSON :: E'EnumNumber -> Value
    toJSON = Double -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Double -> Value)
    -> (E'EnumNumber -> Double) -> E'EnumNumber -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumNumber -> Double
    fromE'EnumNumber
    instance A.FromJSON E'EnumNumber where parseJSON :: Value -> Parser E'EnumNumber
    parseJSON Value
    o = ([Char] -> Parser E'EnumNumber)
    -> (E'EnumNumber -> Parser E'EnumNumber)
    -> Either [Char] E'EnumNumber
    -> Parser E'EnumNumber
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'EnumNumber
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'EnumNumber -> Parser E'EnumNumber
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'EnumNumber -> Parser E'EnumNumber)
    -> (E'EnumNumber -> E'EnumNumber)
    -> E'EnumNumber
    -> Parser E'EnumNumber
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumNumber -> E'EnumNumber
    forall a. a -> a
    P.id) (Either [Char] E'EnumNumber -> Parser E'EnumNumber)
    -> (Double -> Either [Char] E'EnumNumber)
    -> Double
    -> Parser E'EnumNumber
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Either [Char] E'EnumNumber
    toE'EnumNumber (Double -> Parser E'EnumNumber)
    -> Parser Double -> Parser E'EnumNumber
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Double
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'EnumNumber where toQueryParam :: E'EnumNumber -> Text
    toQueryParam = Double -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Double -> Text)
    -> (E'EnumNumber -> Double) -> E'EnumNumber -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumNumber -> Double
    fromE'EnumNumber
    instance WH.FromHttpApiData E'EnumNumber where parseQueryParam :: Text -> Either Text E'EnumNumber
    parseQueryParam Text
    o = Text -> Either Text Double
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Double
    -> (Double -> Either Text E'EnumNumber) -> Either Text E'EnumNumber
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] E'EnumNumber -> Either Text E'EnumNumber
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'EnumNumber -> Either Text E'EnumNumber)
    -> (Double -> Either [Char] E'EnumNumber)
    -> Double
    -> Either Text E'EnumNumber
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Either [Char] E'EnumNumber
    toE'EnumNumber
    instance MimeRender MimeMultipartFormData E'EnumNumber where mimeRender :: Proxy MimeMultipartFormData -> E'EnumNumber -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'EnumNumber -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'EnumNumber' enum
    fromE'EnumNumber :: E'EnumNumber -> Double
    fromE'EnumNumber :: E'EnumNumber -> Double
    fromE'EnumNumber = \case
      E'EnumNumber
    E'EnumNumber'Num1_Dot_1 -> Double
    1.1
      E'EnumNumber
    E'EnumNumber'NumMinus_1_Dot_2 -> -Double
    1.2

    -- | parse 'E'EnumNumber' enum
    toE'EnumNumber :: Double -> P.Either String E'EnumNumber
    toE'EnumNumber :: Double -> Either [Char] E'EnumNumber
    toE'EnumNumber = \case
      Double
    1.1 -> E'EnumNumber -> Either [Char] E'EnumNumber
    forall a b. b -> Either a b
    P.Right E'EnumNumber
    E'EnumNumber'Num1_Dot_1
      -1.2 -> E'EnumNumber -> Either [Char] E'EnumNumber
    forall a b. b -> Either a b
    P.Right E'EnumNumber
    E'EnumNumber'NumMinus_1_Dot_2
      Double
    s -> [Char] -> Either [Char] E'EnumNumber
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'EnumNumber)
    -> [Char] -> Either [Char] E'EnumNumber
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'EnumNumber: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Double -> [Char]
    forall a. Show a => a -> [Char]
    P.show Double
    s

    -- ** E'EnumQueryInteger

    -- | Enum of 'Int'
    data E'EnumQueryInteger
      = E'EnumQueryInteger'Num1 -- ^ @1@
      | E'EnumQueryInteger'NumMinus_2 -- ^ @-2@
      deriving (Int -> E'EnumQueryInteger -> ShowS
    [E'EnumQueryInteger] -> ShowS
    E'EnumQueryInteger -> [Char]
    (Int -> E'EnumQueryInteger -> ShowS)
    -> (E'EnumQueryInteger -> [Char])
    -> ([E'EnumQueryInteger] -> ShowS)
    -> Show E'EnumQueryInteger
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'EnumQueryInteger -> ShowS
    showsPrec :: Int -> E'EnumQueryInteger -> ShowS
    $cshow :: E'EnumQueryInteger -> [Char]
    show :: E'EnumQueryInteger -> [Char]
    $cshowList :: [E'EnumQueryInteger] -> ShowS
    showList :: [E'EnumQueryInteger] -> ShowS
    P.Show, E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    (E'EnumQueryInteger -> E'EnumQueryInteger -> Bool)
    -> (E'EnumQueryInteger -> E'EnumQueryInteger -> Bool)
    -> Eq E'EnumQueryInteger
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    == :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    $c/= :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    /= :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    P.Eq, P.Typeable, Eq E'EnumQueryInteger
    Eq E'EnumQueryInteger
    -> (E'EnumQueryInteger -> E'EnumQueryInteger -> Ordering)
    -> (E'EnumQueryInteger -> E'EnumQueryInteger -> Bool)
    -> (E'EnumQueryInteger -> E'EnumQueryInteger -> Bool)
    -> (E'EnumQueryInteger -> E'EnumQueryInteger -> Bool)
    -> (E'EnumQueryInteger -> E'EnumQueryInteger -> Bool)
    -> (E'EnumQueryInteger -> E'EnumQueryInteger -> E'EnumQueryInteger)
    -> (E'EnumQueryInteger -> E'EnumQueryInteger -> E'EnumQueryInteger)
    -> Ord E'EnumQueryInteger
    E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    E'EnumQueryInteger -> E'EnumQueryInteger -> Ordering
    E'EnumQueryInteger -> E'EnumQueryInteger -> E'EnumQueryInteger
    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
    $ccompare :: E'EnumQueryInteger -> E'EnumQueryInteger -> Ordering
    compare :: E'EnumQueryInteger -> E'EnumQueryInteger -> Ordering
    $c< :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    < :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    $c<= :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    <= :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    $c> :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    > :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    $c>= :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    >= :: E'EnumQueryInteger -> E'EnumQueryInteger -> Bool
    $cmax :: E'EnumQueryInteger -> E'EnumQueryInteger -> E'EnumQueryInteger
    max :: E'EnumQueryInteger -> E'EnumQueryInteger -> E'EnumQueryInteger
    $cmin :: E'EnumQueryInteger -> E'EnumQueryInteger -> E'EnumQueryInteger
    min :: E'EnumQueryInteger -> E'EnumQueryInteger -> E'EnumQueryInteger
    P.Ord, E'EnumQueryInteger
    E'EnumQueryInteger
    -> E'EnumQueryInteger -> Bounded E'EnumQueryInteger
    forall a. a -> a -> Bounded a
    $cminBound :: E'EnumQueryInteger
    minBound :: E'EnumQueryInteger
    $cmaxBound :: E'EnumQueryInteger
    maxBound :: E'EnumQueryInteger
    P.Bounded, Int -> E'EnumQueryInteger
    E'EnumQueryInteger -> Int
    E'EnumQueryInteger -> [E'EnumQueryInteger]
    E'EnumQueryInteger -> E'EnumQueryInteger
    E'EnumQueryInteger -> E'EnumQueryInteger -> [E'EnumQueryInteger]
    E'EnumQueryInteger
    -> E'EnumQueryInteger -> E'EnumQueryInteger -> [E'EnumQueryInteger]
    (E'EnumQueryInteger -> E'EnumQueryInteger)
    -> (E'EnumQueryInteger -> E'EnumQueryInteger)
    -> (Int -> E'EnumQueryInteger)
    -> (E'EnumQueryInteger -> Int)
    -> (E'EnumQueryInteger -> [E'EnumQueryInteger])
    -> (E'EnumQueryInteger
        -> E'EnumQueryInteger -> [E'EnumQueryInteger])
    -> (E'EnumQueryInteger
        -> E'EnumQueryInteger -> [E'EnumQueryInteger])
    -> (E'EnumQueryInteger
        -> E'EnumQueryInteger
        -> E'EnumQueryInteger
        -> [E'EnumQueryInteger])
    -> Enum E'EnumQueryInteger
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'EnumQueryInteger -> E'EnumQueryInteger
    succ :: E'EnumQueryInteger -> E'EnumQueryInteger
    $cpred :: E'EnumQueryInteger -> E'EnumQueryInteger
    pred :: E'EnumQueryInteger -> E'EnumQueryInteger
    $ctoEnum :: Int -> E'EnumQueryInteger
    toEnum :: Int -> E'EnumQueryInteger
    $cfromEnum :: E'EnumQueryInteger -> Int
    fromEnum :: E'EnumQueryInteger -> Int
    $cenumFrom :: E'EnumQueryInteger -> [E'EnumQueryInteger]
    enumFrom :: E'EnumQueryInteger -> [E'EnumQueryInteger]
    $cenumFromThen :: E'EnumQueryInteger -> E'EnumQueryInteger -> [E'EnumQueryInteger]
    enumFromThen :: E'EnumQueryInteger -> E'EnumQueryInteger -> [E'EnumQueryInteger]
    $cenumFromTo :: E'EnumQueryInteger -> E'EnumQueryInteger -> [E'EnumQueryInteger]
    enumFromTo :: E'EnumQueryInteger -> E'EnumQueryInteger -> [E'EnumQueryInteger]
    $cenumFromThenTo :: E'EnumQueryInteger
    -> E'EnumQueryInteger -> E'EnumQueryInteger -> [E'EnumQueryInteger]
    enumFromThenTo :: E'EnumQueryInteger
    -> E'EnumQueryInteger -> E'EnumQueryInteger -> [E'EnumQueryInteger]
    P.Enum)

    instance A.ToJSON E'EnumQueryInteger where toJSON :: E'EnumQueryInteger -> Value
    toJSON = Int -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Int -> Value)
    -> (E'EnumQueryInteger -> Int) -> E'EnumQueryInteger -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumQueryInteger -> Int
    fromE'EnumQueryInteger
    instance A.FromJSON E'EnumQueryInteger where parseJSON :: Value -> Parser E'EnumQueryInteger
    parseJSON Value
    o = ([Char] -> Parser E'EnumQueryInteger)
    -> (E'EnumQueryInteger -> Parser E'EnumQueryInteger)
    -> Either [Char] E'EnumQueryInteger
    -> Parser E'EnumQueryInteger
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'EnumQueryInteger
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'EnumQueryInteger -> Parser E'EnumQueryInteger
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'EnumQueryInteger -> Parser E'EnumQueryInteger)
    -> (E'EnumQueryInteger -> E'EnumQueryInteger)
    -> E'EnumQueryInteger
    -> Parser E'EnumQueryInteger
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumQueryInteger -> E'EnumQueryInteger
    forall a. a -> a
    P.id) (Either [Char] E'EnumQueryInteger -> Parser E'EnumQueryInteger)
    -> (Int -> Either [Char] E'EnumQueryInteger)
    -> Int
    -> Parser E'EnumQueryInteger
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Either [Char] E'EnumQueryInteger
    toE'EnumQueryInteger (Int -> Parser E'EnumQueryInteger)
    -> Parser Int -> Parser E'EnumQueryInteger
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Int
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'EnumQueryInteger where toQueryParam :: E'EnumQueryInteger -> Text
    toQueryParam = Int -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Int -> Text)
    -> (E'EnumQueryInteger -> Int) -> E'EnumQueryInteger -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumQueryInteger -> Int
    fromE'EnumQueryInteger
    instance WH.FromHttpApiData E'EnumQueryInteger where parseQueryParam :: Text -> Either Text E'EnumQueryInteger
    parseQueryParam Text
    o = Text -> Either Text Int
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Int
    -> (Int -> Either Text E'EnumQueryInteger)
    -> Either Text E'EnumQueryInteger
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] E'EnumQueryInteger
    -> Either Text E'EnumQueryInteger
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'EnumQueryInteger
     -> Either Text E'EnumQueryInteger)
    -> (Int -> Either [Char] E'EnumQueryInteger)
    -> Int
    -> Either Text E'EnumQueryInteger
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Either [Char] E'EnumQueryInteger
    toE'EnumQueryInteger
    instance MimeRender MimeMultipartFormData E'EnumQueryInteger where mimeRender :: Proxy MimeMultipartFormData -> E'EnumQueryInteger -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'EnumQueryInteger -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'EnumQueryInteger' enum
    fromE'EnumQueryInteger :: E'EnumQueryInteger -> Int
    fromE'EnumQueryInteger :: E'EnumQueryInteger -> Int
    fromE'EnumQueryInteger = \case
      E'EnumQueryInteger
    E'EnumQueryInteger'Num1 -> Int
    1
      E'EnumQueryInteger
    E'EnumQueryInteger'NumMinus_2 -> -Int
    2

    -- | parse 'E'EnumQueryInteger' enum
    toE'EnumQueryInteger :: Int -> P.Either String E'EnumQueryInteger
    toE'EnumQueryInteger :: Int -> Either [Char] E'EnumQueryInteger
    toE'EnumQueryInteger = \case
      Int
    1 -> E'EnumQueryInteger -> Either [Char] E'EnumQueryInteger
    forall a b. b -> Either a b
    P.Right E'EnumQueryInteger
    E'EnumQueryInteger'Num1
      -2 -> E'EnumQueryInteger -> Either [Char] E'EnumQueryInteger
    forall a b. b -> Either a b
    P.Right E'EnumQueryInteger
    E'EnumQueryInteger'NumMinus_2
      Int
    s -> [Char] -> Either [Char] E'EnumQueryInteger
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'EnumQueryInteger)
    -> [Char] -> Either [Char] E'EnumQueryInteger
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'EnumQueryInteger: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Int -> [Char]
    forall a. Show a => a -> [Char]
    P.show Int
    s

    -- ** E'EnumString

    -- | Enum of 'Text'
    data E'EnumString
      = E'EnumString'UPPER -- ^ @"UPPER"@
      | E'EnumString'Lower -- ^ @"lower"@
      | E'EnumString'Empty -- ^ @""@
      deriving (Int -> E'EnumString -> ShowS
    [E'EnumString] -> ShowS
    E'EnumString -> [Char]
    (Int -> E'EnumString -> ShowS)
    -> (E'EnumString -> [Char])
    -> ([E'EnumString] -> ShowS)
    -> Show E'EnumString
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'EnumString -> ShowS
    showsPrec :: Int -> E'EnumString -> ShowS
    $cshow :: E'EnumString -> [Char]
    show :: E'EnumString -> [Char]
    $cshowList :: [E'EnumString] -> ShowS
    showList :: [E'EnumString] -> ShowS
    P.Show, E'EnumString -> E'EnumString -> Bool
    (E'EnumString -> E'EnumString -> Bool)
    -> (E'EnumString -> E'EnumString -> Bool) -> Eq E'EnumString
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'EnumString -> E'EnumString -> Bool
    == :: E'EnumString -> E'EnumString -> Bool
    $c/= :: E'EnumString -> E'EnumString -> Bool
    /= :: E'EnumString -> E'EnumString -> Bool
    P.Eq, P.Typeable, Eq E'EnumString
    Eq E'EnumString
    -> (E'EnumString -> E'EnumString -> Ordering)
    -> (E'EnumString -> E'EnumString -> Bool)
    -> (E'EnumString -> E'EnumString -> Bool)
    -> (E'EnumString -> E'EnumString -> Bool)
    -> (E'EnumString -> E'EnumString -> Bool)
    -> (E'EnumString -> E'EnumString -> E'EnumString)
    -> (E'EnumString -> E'EnumString -> E'EnumString)
    -> Ord E'EnumString
    E'EnumString -> E'EnumString -> Bool
    E'EnumString -> E'EnumString -> Ordering
    E'EnumString -> E'EnumString -> E'EnumString
    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
    $ccompare :: E'EnumString -> E'EnumString -> Ordering
    compare :: E'EnumString -> E'EnumString -> Ordering
    $c< :: E'EnumString -> E'EnumString -> Bool
    < :: E'EnumString -> E'EnumString -> Bool
    $c<= :: E'EnumString -> E'EnumString -> Bool
    <= :: E'EnumString -> E'EnumString -> Bool
    $c> :: E'EnumString -> E'EnumString -> Bool
    > :: E'EnumString -> E'EnumString -> Bool
    $c>= :: E'EnumString -> E'EnumString -> Bool
    >= :: E'EnumString -> E'EnumString -> Bool
    $cmax :: E'EnumString -> E'EnumString -> E'EnumString
    max :: E'EnumString -> E'EnumString -> E'EnumString
    $cmin :: E'EnumString -> E'EnumString -> E'EnumString
    min :: E'EnumString -> E'EnumString -> E'EnumString
    P.Ord, E'EnumString
    E'EnumString -> E'EnumString -> Bounded E'EnumString
    forall a. a -> a -> Bounded a
    $cminBound :: E'EnumString
    minBound :: E'EnumString
    $cmaxBound :: E'EnumString
    maxBound :: E'EnumString
    P.Bounded, Int -> E'EnumString
    E'EnumString -> Int
    E'EnumString -> [E'EnumString]
    E'EnumString -> E'EnumString
    E'EnumString -> E'EnumString -> [E'EnumString]
    E'EnumString -> E'EnumString -> E'EnumString -> [E'EnumString]
    (E'EnumString -> E'EnumString)
    -> (E'EnumString -> E'EnumString)
    -> (Int -> E'EnumString)
    -> (E'EnumString -> Int)
    -> (E'EnumString -> [E'EnumString])
    -> (E'EnumString -> E'EnumString -> [E'EnumString])
    -> (E'EnumString -> E'EnumString -> [E'EnumString])
    -> (E'EnumString -> E'EnumString -> E'EnumString -> [E'EnumString])
    -> Enum E'EnumString
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'EnumString -> E'EnumString
    succ :: E'EnumString -> E'EnumString
    $cpred :: E'EnumString -> E'EnumString
    pred :: E'EnumString -> E'EnumString
    $ctoEnum :: Int -> E'EnumString
    toEnum :: Int -> E'EnumString
    $cfromEnum :: E'EnumString -> Int
    fromEnum :: E'EnumString -> Int
    $cenumFrom :: E'EnumString -> [E'EnumString]
    enumFrom :: E'EnumString -> [E'EnumString]
    $cenumFromThen :: E'EnumString -> E'EnumString -> [E'EnumString]
    enumFromThen :: E'EnumString -> E'EnumString -> [E'EnumString]
    $cenumFromTo :: E'EnumString -> E'EnumString -> [E'EnumString]
    enumFromTo :: E'EnumString -> E'EnumString -> [E'EnumString]
    $cenumFromThenTo :: E'EnumString -> E'EnumString -> E'EnumString -> [E'EnumString]
    enumFromThenTo :: E'EnumString -> E'EnumString -> E'EnumString -> [E'EnumString]
    P.Enum)

    instance A.ToJSON E'EnumString where toJSON :: E'EnumString -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value) -> (E'EnumString -> Text) -> E'EnumString -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumString -> Text
    fromE'EnumString
    instance A.FromJSON E'EnumString where parseJSON :: Value -> Parser E'EnumString
    parseJSON Value
    o = ([Char] -> Parser E'EnumString)
    -> (E'EnumString -> Parser E'EnumString)
    -> Either [Char] E'EnumString
    -> Parser E'EnumString
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'EnumString
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'EnumString -> Parser E'EnumString
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'EnumString -> Parser E'EnumString)
    -> (E'EnumString -> E'EnumString)
    -> E'EnumString
    -> Parser E'EnumString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumString -> E'EnumString
    forall a. a -> a
    P.id) (Either [Char] E'EnumString -> Parser E'EnumString)
    -> (Text -> Either [Char] E'EnumString)
    -> Text
    -> Parser E'EnumString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'EnumString
    toE'EnumString (Text -> Parser E'EnumString) -> Parser Text -> Parser E'EnumString
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'EnumString where toQueryParam :: E'EnumString -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text) -> (E'EnumString -> Text) -> E'EnumString -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'EnumString -> Text
    fromE'EnumString
    instance WH.FromHttpApiData E'EnumString where parseQueryParam :: Text -> Either Text E'EnumString
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text E'EnumString) -> Either Text E'EnumString
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] E'EnumString -> Either Text E'EnumString
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'EnumString -> Either Text E'EnumString)
    -> (Text -> Either [Char] E'EnumString)
    -> Text
    -> Either Text E'EnumString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'EnumString
    toE'EnumString
    instance MimeRender MimeMultipartFormData E'EnumString where mimeRender :: Proxy MimeMultipartFormData -> E'EnumString -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'EnumString -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'EnumString' enum
    fromE'EnumString :: E'EnumString -> Text
    fromE'EnumString :: E'EnumString -> Text
    fromE'EnumString = \case
      E'EnumString
    E'EnumString'UPPER -> Text
    "UPPER"
      E'EnumString
    E'EnumString'Lower -> Text
    "lower"
      E'EnumString
    E'EnumString'Empty -> Text
    ""

    -- | parse 'E'EnumString' enum
    toE'EnumString :: Text -> P.Either String E'EnumString
    toE'EnumString :: Text -> Either [Char] E'EnumString
    toE'EnumString = \case
      Text
    "UPPER" -> E'EnumString -> Either [Char] E'EnumString
    forall a b. b -> Either a b
    P.Right E'EnumString
    E'EnumString'UPPER
      Text
    "lower" -> E'EnumString -> Either [Char] E'EnumString
    forall a b. b -> Either a b
    P.Right E'EnumString
    E'EnumString'Lower
      Text
    "" -> E'EnumString -> Either [Char] E'EnumString
    forall a b. b -> Either a b
    P.Right E'EnumString
    E'EnumString'Empty
      Text
    s -> [Char] -> Either [Char] E'EnumString
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'EnumString)
    -> [Char] -> Either [Char] E'EnumString
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'EnumString: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- ** E'Inner

    -- | Enum of 'Text'
    data E'Inner
      = E'Inner'UPPER -- ^ @"UPPER"@
      | E'Inner'Lower -- ^ @"lower"@
      deriving (Int -> E'Inner -> ShowS
    [E'Inner] -> ShowS
    E'Inner -> [Char]
    (Int -> E'Inner -> ShowS)
    -> (E'Inner -> [Char]) -> ([E'Inner] -> ShowS) -> Show E'Inner
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'Inner -> ShowS
    showsPrec :: Int -> E'Inner -> ShowS
    $cshow :: E'Inner -> [Char]
    show :: E'Inner -> [Char]
    $cshowList :: [E'Inner] -> ShowS
    showList :: [E'Inner] -> ShowS
    P.Show, E'Inner -> E'Inner -> Bool
    (E'Inner -> E'Inner -> Bool)
    -> (E'Inner -> E'Inner -> Bool) -> Eq E'Inner
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'Inner -> E'Inner -> Bool
    == :: E'Inner -> E'Inner -> Bool
    $c/= :: E'Inner -> E'Inner -> Bool
    /= :: E'Inner -> E'Inner -> Bool
    P.Eq, P.Typeable, Eq E'Inner
    Eq E'Inner
    -> (E'Inner -> E'Inner -> Ordering)
    -> (E'Inner -> E'Inner -> Bool)
    -> (E'Inner -> E'Inner -> Bool)
    -> (E'Inner -> E'Inner -> Bool)
    -> (E'Inner -> E'Inner -> Bool)
    -> (E'Inner -> E'Inner -> E'Inner)
    -> (E'Inner -> E'Inner -> E'Inner)
    -> Ord E'Inner
    E'Inner -> E'Inner -> Bool
    E'Inner -> E'Inner -> Ordering
    E'Inner -> E'Inner -> E'Inner
    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
    $ccompare :: E'Inner -> E'Inner -> Ordering
    compare :: E'Inner -> E'Inner -> Ordering
    $c< :: E'Inner -> E'Inner -> Bool
    < :: E'Inner -> E'Inner -> Bool
    $c<= :: E'Inner -> E'Inner -> Bool
    <= :: E'Inner -> E'Inner -> Bool
    $c> :: E'Inner -> E'Inner -> Bool
    > :: E'Inner -> E'Inner -> Bool
    $c>= :: E'Inner -> E'Inner -> Bool
    >= :: E'Inner -> E'Inner -> Bool
    $cmax :: E'Inner -> E'Inner -> E'Inner
    max :: E'Inner -> E'Inner -> E'Inner
    $cmin :: E'Inner -> E'Inner -> E'Inner
    min :: E'Inner -> E'Inner -> E'Inner
    P.Ord, E'Inner
    E'Inner -> E'Inner -> Bounded E'Inner
    forall a. a -> a -> Bounded a
    $cminBound :: E'Inner
    minBound :: E'Inner
    $cmaxBound :: E'Inner
    maxBound :: E'Inner
    P.Bounded, Int -> E'Inner
    E'Inner -> Int
    E'Inner -> [E'Inner]
    E'Inner -> E'Inner
    E'Inner -> E'Inner -> [E'Inner]
    E'Inner -> E'Inner -> E'Inner -> [E'Inner]
    (E'Inner -> E'Inner)
    -> (E'Inner -> E'Inner)
    -> (Int -> E'Inner)
    -> (E'Inner -> Int)
    -> (E'Inner -> [E'Inner])
    -> (E'Inner -> E'Inner -> [E'Inner])
    -> (E'Inner -> E'Inner -> [E'Inner])
    -> (E'Inner -> E'Inner -> E'Inner -> [E'Inner])
    -> Enum E'Inner
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'Inner -> E'Inner
    succ :: E'Inner -> E'Inner
    $cpred :: E'Inner -> E'Inner
    pred :: E'Inner -> E'Inner
    $ctoEnum :: Int -> E'Inner
    toEnum :: Int -> E'Inner
    $cfromEnum :: E'Inner -> Int
    fromEnum :: E'Inner -> Int
    $cenumFrom :: E'Inner -> [E'Inner]
    enumFrom :: E'Inner -> [E'Inner]
    $cenumFromThen :: E'Inner -> E'Inner -> [E'Inner]
    enumFromThen :: E'Inner -> E'Inner -> [E'Inner]
    $cenumFromTo :: E'Inner -> E'Inner -> [E'Inner]
    enumFromTo :: E'Inner -> E'Inner -> [E'Inner]
    $cenumFromThenTo :: E'Inner -> E'Inner -> E'Inner -> [E'Inner]
    enumFromThenTo :: E'Inner -> E'Inner -> E'Inner -> [E'Inner]
    P.Enum)

    instance A.ToJSON E'Inner where toJSON :: E'Inner -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value) -> (E'Inner -> Text) -> E'Inner -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Inner -> Text
    fromE'Inner
    instance A.FromJSON E'Inner where parseJSON :: Value -> Parser E'Inner
    parseJSON Value
    o = ([Char] -> Parser E'Inner)
    -> (E'Inner -> Parser E'Inner)
    -> Either [Char] E'Inner
    -> Parser E'Inner
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'Inner
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'Inner -> Parser E'Inner
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'Inner -> Parser E'Inner)
    -> (E'Inner -> E'Inner) -> E'Inner -> Parser E'Inner
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Inner -> E'Inner
    forall a. a -> a
    P.id) (Either [Char] E'Inner -> Parser E'Inner)
    -> (Text -> Either [Char] E'Inner) -> Text -> Parser E'Inner
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'Inner
    toE'Inner (Text -> Parser E'Inner) -> Parser Text -> Parser E'Inner
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'Inner where toQueryParam :: E'Inner -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text) -> (E'Inner -> Text) -> E'Inner -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Inner -> Text
    fromE'Inner
    instance WH.FromHttpApiData E'Inner where parseQueryParam :: Text -> Either Text E'Inner
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text E'Inner) -> Either Text E'Inner
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text) -> Either [Char] E'Inner -> Either Text E'Inner
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'Inner -> Either Text E'Inner)
    -> (Text -> Either [Char] E'Inner) -> Text -> Either Text E'Inner
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'Inner
    toE'Inner
    instance MimeRender MimeMultipartFormData E'Inner where mimeRender :: Proxy MimeMultipartFormData -> E'Inner -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'Inner -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'Inner' enum
    fromE'Inner :: E'Inner -> Text
    fromE'Inner :: E'Inner -> Text
    fromE'Inner = \case
      E'Inner
    E'Inner'UPPER -> Text
    "UPPER"
      E'Inner
    E'Inner'Lower -> Text
    "lower"

    -- | parse 'E'Inner' enum
    toE'Inner :: Text -> P.Either String E'Inner
    toE'Inner :: Text -> Either [Char] E'Inner
    toE'Inner = \case
      Text
    "UPPER" -> E'Inner -> Either [Char] E'Inner
    forall a b. b -> Either a b
    P.Right E'Inner
    E'Inner'UPPER
      Text
    "lower" -> E'Inner -> Either [Char] E'Inner
    forall a b. b -> Either a b
    P.Right E'Inner
    E'Inner'Lower
      Text
    s -> [Char] -> Either [Char] E'Inner
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'Inner)
    -> [Char] -> Either [Char] E'Inner
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'Inner: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- ** E'JustSymbol

    -- | Enum of 'Text'
    data E'JustSymbol
      = E'JustSymbol'Greater_Than_Or_Equal_To -- ^ @">="@
      | E'JustSymbol'Dollar -- ^ @"$"@
      deriving (Int -> E'JustSymbol -> ShowS
    [E'JustSymbol] -> ShowS
    E'JustSymbol -> [Char]
    (Int -> E'JustSymbol -> ShowS)
    -> (E'JustSymbol -> [Char])
    -> ([E'JustSymbol] -> ShowS)
    -> Show E'JustSymbol
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'JustSymbol -> ShowS
    showsPrec :: Int -> E'JustSymbol -> ShowS
    $cshow :: E'JustSymbol -> [Char]
    show :: E'JustSymbol -> [Char]
    $cshowList :: [E'JustSymbol] -> ShowS
    showList :: [E'JustSymbol] -> ShowS
    P.Show, E'JustSymbol -> E'JustSymbol -> Bool
    (E'JustSymbol -> E'JustSymbol -> Bool)
    -> (E'JustSymbol -> E'JustSymbol -> Bool) -> Eq E'JustSymbol
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'JustSymbol -> E'JustSymbol -> Bool
    == :: E'JustSymbol -> E'JustSymbol -> Bool
    $c/= :: E'JustSymbol -> E'JustSymbol -> Bool
    /= :: E'JustSymbol -> E'JustSymbol -> Bool
    P.Eq, P.Typeable, Eq E'JustSymbol
    Eq E'JustSymbol
    -> (E'JustSymbol -> E'JustSymbol -> Ordering)
    -> (E'JustSymbol -> E'JustSymbol -> Bool)
    -> (E'JustSymbol -> E'JustSymbol -> Bool)
    -> (E'JustSymbol -> E'JustSymbol -> Bool)
    -> (E'JustSymbol -> E'JustSymbol -> Bool)
    -> (E'JustSymbol -> E'JustSymbol -> E'JustSymbol)
    -> (E'JustSymbol -> E'JustSymbol -> E'JustSymbol)
    -> Ord E'JustSymbol
    E'JustSymbol -> E'JustSymbol -> Bool
    E'JustSymbol -> E'JustSymbol -> Ordering
    E'JustSymbol -> E'JustSymbol -> E'JustSymbol
    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
    $ccompare :: E'JustSymbol -> E'JustSymbol -> Ordering
    compare :: E'JustSymbol -> E'JustSymbol -> Ordering
    $c< :: E'JustSymbol -> E'JustSymbol -> Bool
    < :: E'JustSymbol -> E'JustSymbol -> Bool
    $c<= :: E'JustSymbol -> E'JustSymbol -> Bool
    <= :: E'JustSymbol -> E'JustSymbol -> Bool
    $c> :: E'JustSymbol -> E'JustSymbol -> Bool
    > :: E'JustSymbol -> E'JustSymbol -> Bool
    $c>= :: E'JustSymbol -> E'JustSymbol -> Bool
    >= :: E'JustSymbol -> E'JustSymbol -> Bool
    $cmax :: E'JustSymbol -> E'JustSymbol -> E'JustSymbol
    max :: E'JustSymbol -> E'JustSymbol -> E'JustSymbol
    $cmin :: E'JustSymbol -> E'JustSymbol -> E'JustSymbol
    min :: E'JustSymbol -> E'JustSymbol -> E'JustSymbol
    P.Ord, E'JustSymbol
    E'JustSymbol -> E'JustSymbol -> Bounded E'JustSymbol
    forall a. a -> a -> Bounded a
    $cminBound :: E'JustSymbol
    minBound :: E'JustSymbol
    $cmaxBound :: E'JustSymbol
    maxBound :: E'JustSymbol
    P.Bounded, Int -> E'JustSymbol
    E'JustSymbol -> Int
    E'JustSymbol -> [E'JustSymbol]
    E'JustSymbol -> E'JustSymbol
    E'JustSymbol -> E'JustSymbol -> [E'JustSymbol]
    E'JustSymbol -> E'JustSymbol -> E'JustSymbol -> [E'JustSymbol]
    (E'JustSymbol -> E'JustSymbol)
    -> (E'JustSymbol -> E'JustSymbol)
    -> (Int -> E'JustSymbol)
    -> (E'JustSymbol -> Int)
    -> (E'JustSymbol -> [E'JustSymbol])
    -> (E'JustSymbol -> E'JustSymbol -> [E'JustSymbol])
    -> (E'JustSymbol -> E'JustSymbol -> [E'JustSymbol])
    -> (E'JustSymbol -> E'JustSymbol -> E'JustSymbol -> [E'JustSymbol])
    -> Enum E'JustSymbol
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'JustSymbol -> E'JustSymbol
    succ :: E'JustSymbol -> E'JustSymbol
    $cpred :: E'JustSymbol -> E'JustSymbol
    pred :: E'JustSymbol -> E'JustSymbol
    $ctoEnum :: Int -> E'JustSymbol
    toEnum :: Int -> E'JustSymbol
    $cfromEnum :: E'JustSymbol -> Int
    fromEnum :: E'JustSymbol -> Int
    $cenumFrom :: E'JustSymbol -> [E'JustSymbol]
    enumFrom :: E'JustSymbol -> [E'JustSymbol]
    $cenumFromThen :: E'JustSymbol -> E'JustSymbol -> [E'JustSymbol]
    enumFromThen :: E'JustSymbol -> E'JustSymbol -> [E'JustSymbol]
    $cenumFromTo :: E'JustSymbol -> E'JustSymbol -> [E'JustSymbol]
    enumFromTo :: E'JustSymbol -> E'JustSymbol -> [E'JustSymbol]
    $cenumFromThenTo :: E'JustSymbol -> E'JustSymbol -> E'JustSymbol -> [E'JustSymbol]
    enumFromThenTo :: E'JustSymbol -> E'JustSymbol -> E'JustSymbol -> [E'JustSymbol]
    P.Enum)

    instance A.ToJSON E'JustSymbol where toJSON :: E'JustSymbol -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value) -> (E'JustSymbol -> Text) -> E'JustSymbol -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'JustSymbol -> Text
    fromE'JustSymbol
    instance A.FromJSON E'JustSymbol where parseJSON :: Value -> Parser E'JustSymbol
    parseJSON Value
    o = ([Char] -> Parser E'JustSymbol)
    -> (E'JustSymbol -> Parser E'JustSymbol)
    -> Either [Char] E'JustSymbol
    -> Parser E'JustSymbol
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'JustSymbol
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'JustSymbol -> Parser E'JustSymbol
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'JustSymbol -> Parser E'JustSymbol)
    -> (E'JustSymbol -> E'JustSymbol)
    -> E'JustSymbol
    -> Parser E'JustSymbol
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'JustSymbol -> E'JustSymbol
    forall a. a -> a
    P.id) (Either [Char] E'JustSymbol -> Parser E'JustSymbol)
    -> (Text -> Either [Char] E'JustSymbol)
    -> Text
    -> Parser E'JustSymbol
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'JustSymbol
    toE'JustSymbol (Text -> Parser E'JustSymbol) -> Parser Text -> Parser E'JustSymbol
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'JustSymbol where toQueryParam :: E'JustSymbol -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text) -> (E'JustSymbol -> Text) -> E'JustSymbol -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'JustSymbol -> Text
    fromE'JustSymbol
    instance WH.FromHttpApiData E'JustSymbol where parseQueryParam :: Text -> Either Text E'JustSymbol
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text E'JustSymbol) -> Either Text E'JustSymbol
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] E'JustSymbol -> Either Text E'JustSymbol
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'JustSymbol -> Either Text E'JustSymbol)
    -> (Text -> Either [Char] E'JustSymbol)
    -> Text
    -> Either Text E'JustSymbol
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'JustSymbol
    toE'JustSymbol
    instance MimeRender MimeMultipartFormData E'JustSymbol where mimeRender :: Proxy MimeMultipartFormData -> E'JustSymbol -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'JustSymbol -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'JustSymbol' enum
    fromE'JustSymbol :: E'JustSymbol -> Text
    fromE'JustSymbol :: E'JustSymbol -> Text
    fromE'JustSymbol = \case
      E'JustSymbol
    E'JustSymbol'Greater_Than_Or_Equal_To -> Text
    ">="
      E'JustSymbol
    E'JustSymbol'Dollar -> Text
    "$"

    -- | parse 'E'JustSymbol' enum
    toE'JustSymbol :: Text -> P.Either String E'JustSymbol
    toE'JustSymbol :: Text -> Either [Char] E'JustSymbol
    toE'JustSymbol = \case
      Text
    ">=" -> E'JustSymbol -> Either [Char] E'JustSymbol
    forall a b. b -> Either a b
    P.Right E'JustSymbol
    E'JustSymbol'Greater_Than_Or_Equal_To
      Text
    "$" -> E'JustSymbol -> Either [Char] E'JustSymbol
    forall a b. b -> Either a b
    P.Right E'JustSymbol
    E'JustSymbol'Dollar
      Text
    s -> [Char] -> Either [Char] E'JustSymbol
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'JustSymbol)
    -> [Char] -> Either [Char] E'JustSymbol
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'JustSymbol: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- ** E'Kind

    -- | Enum of 'Text'
    data E'Kind
      = E'Kind'Lions -- ^ @"lions"@
      | E'Kind'Tigers -- ^ @"tigers"@
      | E'Kind'Leopards -- ^ @"leopards"@
      | E'Kind'Jaguars -- ^ @"jaguars"@
      deriving (Int -> E'Kind -> ShowS
    [E'Kind] -> ShowS
    E'Kind -> [Char]
    (Int -> E'Kind -> ShowS)
    -> (E'Kind -> [Char]) -> ([E'Kind] -> ShowS) -> Show E'Kind
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'Kind -> ShowS
    showsPrec :: Int -> E'Kind -> ShowS
    $cshow :: E'Kind -> [Char]
    show :: E'Kind -> [Char]
    $cshowList :: [E'Kind] -> ShowS
    showList :: [E'Kind] -> ShowS
    P.Show, E'Kind -> E'Kind -> Bool
    (E'Kind -> E'Kind -> Bool)
    -> (E'Kind -> E'Kind -> Bool) -> Eq E'Kind
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'Kind -> E'Kind -> Bool
    == :: E'Kind -> E'Kind -> Bool
    $c/= :: E'Kind -> E'Kind -> Bool
    /= :: E'Kind -> E'Kind -> Bool
    P.Eq, P.Typeable, Eq E'Kind
    Eq E'Kind
    -> (E'Kind -> E'Kind -> Ordering)
    -> (E'Kind -> E'Kind -> Bool)
    -> (E'Kind -> E'Kind -> Bool)
    -> (E'Kind -> E'Kind -> Bool)
    -> (E'Kind -> E'Kind -> Bool)
    -> (E'Kind -> E'Kind -> E'Kind)
    -> (E'Kind -> E'Kind -> E'Kind)
    -> Ord E'Kind
    E'Kind -> E'Kind -> Bool
    E'Kind -> E'Kind -> Ordering
    E'Kind -> E'Kind -> E'Kind
    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
    $ccompare :: E'Kind -> E'Kind -> Ordering
    compare :: E'Kind -> E'Kind -> Ordering
    $c< :: E'Kind -> E'Kind -> Bool
    < :: E'Kind -> E'Kind -> Bool
    $c<= :: E'Kind -> E'Kind -> Bool
    <= :: E'Kind -> E'Kind -> Bool
    $c> :: E'Kind -> E'Kind -> Bool
    > :: E'Kind -> E'Kind -> Bool
    $c>= :: E'Kind -> E'Kind -> Bool
    >= :: E'Kind -> E'Kind -> Bool
    $cmax :: E'Kind -> E'Kind -> E'Kind
    max :: E'Kind -> E'Kind -> E'Kind
    $cmin :: E'Kind -> E'Kind -> E'Kind
    min :: E'Kind -> E'Kind -> E'Kind
    P.Ord, E'Kind
    E'Kind -> E'Kind -> Bounded E'Kind
    forall a. a -> a -> Bounded a
    $cminBound :: E'Kind
    minBound :: E'Kind
    $cmaxBound :: E'Kind
    maxBound :: E'Kind
    P.Bounded, Int -> E'Kind
    E'Kind -> Int
    E'Kind -> [E'Kind]
    E'Kind -> E'Kind
    E'Kind -> E'Kind -> [E'Kind]
    E'Kind -> E'Kind -> E'Kind -> [E'Kind]
    (E'Kind -> E'Kind)
    -> (E'Kind -> E'Kind)
    -> (Int -> E'Kind)
    -> (E'Kind -> Int)
    -> (E'Kind -> [E'Kind])
    -> (E'Kind -> E'Kind -> [E'Kind])
    -> (E'Kind -> E'Kind -> [E'Kind])
    -> (E'Kind -> E'Kind -> E'Kind -> [E'Kind])
    -> Enum E'Kind
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'Kind -> E'Kind
    succ :: E'Kind -> E'Kind
    $cpred :: E'Kind -> E'Kind
    pred :: E'Kind -> E'Kind
    $ctoEnum :: Int -> E'Kind
    toEnum :: Int -> E'Kind
    $cfromEnum :: E'Kind -> Int
    fromEnum :: E'Kind -> Int
    $cenumFrom :: E'Kind -> [E'Kind]
    enumFrom :: E'Kind -> [E'Kind]
    $cenumFromThen :: E'Kind -> E'Kind -> [E'Kind]
    enumFromThen :: E'Kind -> E'Kind -> [E'Kind]
    $cenumFromTo :: E'Kind -> E'Kind -> [E'Kind]
    enumFromTo :: E'Kind -> E'Kind -> [E'Kind]
    $cenumFromThenTo :: E'Kind -> E'Kind -> E'Kind -> [E'Kind]
    enumFromThenTo :: E'Kind -> E'Kind -> E'Kind -> [E'Kind]
    P.Enum)

    instance A.ToJSON E'Kind where toJSON :: E'Kind -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value) -> (E'Kind -> Text) -> E'Kind -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Kind -> Text
    fromE'Kind
    instance A.FromJSON E'Kind where parseJSON :: Value -> Parser E'Kind
    parseJSON Value
    o = ([Char] -> Parser E'Kind)
    -> (E'Kind -> Parser E'Kind)
    -> Either [Char] E'Kind
    -> Parser E'Kind
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'Kind
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'Kind -> Parser E'Kind
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'Kind -> Parser E'Kind)
    -> (E'Kind -> E'Kind) -> E'Kind -> Parser E'Kind
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Kind -> E'Kind
    forall a. a -> a
    P.id) (Either [Char] E'Kind -> Parser E'Kind)
    -> (Text -> Either [Char] E'Kind) -> Text -> Parser E'Kind
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'Kind
    toE'Kind (Text -> Parser E'Kind) -> Parser Text -> Parser E'Kind
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'Kind where toQueryParam :: E'Kind -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text) -> (E'Kind -> Text) -> E'Kind -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Kind -> Text
    fromE'Kind
    instance WH.FromHttpApiData E'Kind where parseQueryParam :: Text -> Either Text E'Kind
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text E'Kind) -> Either Text E'Kind
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text) -> Either [Char] E'Kind -> Either Text E'Kind
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'Kind -> Either Text E'Kind)
    -> (Text -> Either [Char] E'Kind) -> Text -> Either Text E'Kind
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'Kind
    toE'Kind
    instance MimeRender MimeMultipartFormData E'Kind where mimeRender :: Proxy MimeMultipartFormData -> E'Kind -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'Kind -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'Kind' enum
    fromE'Kind :: E'Kind -> Text
    fromE'Kind :: E'Kind -> Text
    fromE'Kind = \case
      E'Kind
    E'Kind'Lions -> Text
    "lions"
      E'Kind
    E'Kind'Tigers -> Text
    "tigers"
      E'Kind
    E'Kind'Leopards -> Text
    "leopards"
      E'Kind
    E'Kind'Jaguars -> Text
    "jaguars"

    -- | parse 'E'Kind' enum
    toE'Kind :: Text -> P.Either String E'Kind
    toE'Kind :: Text -> Either [Char] E'Kind
    toE'Kind = \case
      Text
    "lions" -> E'Kind -> Either [Char] E'Kind
    forall a b. b -> Either a b
    P.Right E'Kind
    E'Kind'Lions
      Text
    "tigers" -> E'Kind -> Either [Char] E'Kind
    forall a b. b -> Either a b
    P.Right E'Kind
    E'Kind'Tigers
      Text
    "leopards" -> E'Kind -> Either [Char] E'Kind
    forall a b. b -> Either a b
    P.Right E'Kind
    E'Kind'Leopards
      Text
    "jaguars" -> E'Kind -> Either [Char] E'Kind
    forall a b. b -> Either a b
    P.Right E'Kind
    E'Kind'Jaguars
      Text
    s -> [Char] -> Either [Char] E'Kind
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'Kind) -> [Char] -> Either [Char] E'Kind
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'Kind: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- ** E'Status

    -- | Enum of 'Text' .
    -- Order Status
    data E'Status
      = E'Status'Placed -- ^ @"placed"@
      | E'Status'Approved -- ^ @"approved"@
      | E'Status'Delivered -- ^ @"delivered"@
      deriving (Int -> E'Status -> ShowS
    [E'Status] -> ShowS
    E'Status -> [Char]
    (Int -> E'Status -> ShowS)
    -> (E'Status -> [Char]) -> ([E'Status] -> ShowS) -> Show E'Status
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'Status -> ShowS
    showsPrec :: Int -> E'Status -> ShowS
    $cshow :: E'Status -> [Char]
    show :: E'Status -> [Char]
    $cshowList :: [E'Status] -> ShowS
    showList :: [E'Status] -> ShowS
    P.Show, E'Status -> E'Status -> Bool
    (E'Status -> E'Status -> Bool)
    -> (E'Status -> E'Status -> Bool) -> Eq E'Status
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'Status -> E'Status -> Bool
    == :: E'Status -> E'Status -> Bool
    $c/= :: E'Status -> E'Status -> Bool
    /= :: E'Status -> E'Status -> Bool
    P.Eq, P.Typeable, Eq E'Status
    Eq E'Status
    -> (E'Status -> E'Status -> Ordering)
    -> (E'Status -> E'Status -> Bool)
    -> (E'Status -> E'Status -> Bool)
    -> (E'Status -> E'Status -> Bool)
    -> (E'Status -> E'Status -> Bool)
    -> (E'Status -> E'Status -> E'Status)
    -> (E'Status -> E'Status -> E'Status)
    -> Ord E'Status
    E'Status -> E'Status -> Bool
    E'Status -> E'Status -> Ordering
    E'Status -> E'Status -> E'Status
    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
    $ccompare :: E'Status -> E'Status -> Ordering
    compare :: E'Status -> E'Status -> Ordering
    $c< :: E'Status -> E'Status -> Bool
    < :: E'Status -> E'Status -> Bool
    $c<= :: E'Status -> E'Status -> Bool
    <= :: E'Status -> E'Status -> Bool
    $c> :: E'Status -> E'Status -> Bool
    > :: E'Status -> E'Status -> Bool
    $c>= :: E'Status -> E'Status -> Bool
    >= :: E'Status -> E'Status -> Bool
    $cmax :: E'Status -> E'Status -> E'Status
    max :: E'Status -> E'Status -> E'Status
    $cmin :: E'Status -> E'Status -> E'Status
    min :: E'Status -> E'Status -> E'Status
    P.Ord, E'Status
    E'Status -> E'Status -> Bounded E'Status
    forall a. a -> a -> Bounded a
    $cminBound :: E'Status
    minBound :: E'Status
    $cmaxBound :: E'Status
    maxBound :: E'Status
    P.Bounded, Int -> E'Status
    E'Status -> Int
    E'Status -> [E'Status]
    E'Status -> E'Status
    E'Status -> E'Status -> [E'Status]
    E'Status -> E'Status -> E'Status -> [E'Status]
    (E'Status -> E'Status)
    -> (E'Status -> E'Status)
    -> (Int -> E'Status)
    -> (E'Status -> Int)
    -> (E'Status -> [E'Status])
    -> (E'Status -> E'Status -> [E'Status])
    -> (E'Status -> E'Status -> [E'Status])
    -> (E'Status -> E'Status -> E'Status -> [E'Status])
    -> Enum E'Status
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'Status -> E'Status
    succ :: E'Status -> E'Status
    $cpred :: E'Status -> E'Status
    pred :: E'Status -> E'Status
    $ctoEnum :: Int -> E'Status
    toEnum :: Int -> E'Status
    $cfromEnum :: E'Status -> Int
    fromEnum :: E'Status -> Int
    $cenumFrom :: E'Status -> [E'Status]
    enumFrom :: E'Status -> [E'Status]
    $cenumFromThen :: E'Status -> E'Status -> [E'Status]
    enumFromThen :: E'Status -> E'Status -> [E'Status]
    $cenumFromTo :: E'Status -> E'Status -> [E'Status]
    enumFromTo :: E'Status -> E'Status -> [E'Status]
    $cenumFromThenTo :: E'Status -> E'Status -> E'Status -> [E'Status]
    enumFromThenTo :: E'Status -> E'Status -> E'Status -> [E'Status]
    P.Enum)

    instance A.ToJSON E'Status where toJSON :: E'Status -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value) -> (E'Status -> Text) -> E'Status -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Status -> Text
    fromE'Status
    instance A.FromJSON E'Status where parseJSON :: Value -> Parser E'Status
    parseJSON Value
    o = ([Char] -> Parser E'Status)
    -> (E'Status -> Parser E'Status)
    -> Either [Char] E'Status
    -> Parser E'Status
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'Status
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'Status -> Parser E'Status
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'Status -> Parser E'Status)
    -> (E'Status -> E'Status) -> E'Status -> Parser E'Status
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Status -> E'Status
    forall a. a -> a
    P.id) (Either [Char] E'Status -> Parser E'Status)
    -> (Text -> Either [Char] E'Status) -> Text -> Parser E'Status
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'Status
    toE'Status (Text -> Parser E'Status) -> Parser Text -> Parser E'Status
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'Status where toQueryParam :: E'Status -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text) -> (E'Status -> Text) -> E'Status -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Status -> Text
    fromE'Status
    instance WH.FromHttpApiData E'Status where parseQueryParam :: Text -> Either Text E'Status
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text E'Status) -> Either Text E'Status
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text) -> Either [Char] E'Status -> Either Text E'Status
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'Status -> Either Text E'Status)
    -> (Text -> Either [Char] E'Status) -> Text -> Either Text E'Status
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'Status
    toE'Status
    instance MimeRender MimeMultipartFormData E'Status where mimeRender :: Proxy MimeMultipartFormData -> E'Status -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'Status -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'Status' enum
    fromE'Status :: E'Status -> Text
    fromE'Status :: E'Status -> Text
    fromE'Status = \case
      E'Status
    E'Status'Placed -> Text
    "placed"
      E'Status
    E'Status'Approved -> Text
    "approved"
      E'Status
    E'Status'Delivered -> Text
    "delivered"

    -- | parse 'E'Status' enum
    toE'Status :: Text -> P.Either String E'Status
    toE'Status :: Text -> Either [Char] E'Status
    toE'Status = \case
      Text
    "placed" -> E'Status -> Either [Char] E'Status
    forall a b. b -> Either a b
    P.Right E'Status
    E'Status'Placed
      Text
    "approved" -> E'Status -> Either [Char] E'Status
    forall a b. b -> Either a b
    P.Right E'Status
    E'Status'Approved
      Text
    "delivered" -> E'Status -> Either [Char] E'Status
    forall a b. b -> Either a b
    P.Right E'Status
    E'Status'Delivered
      Text
    s -> [Char] -> Either [Char] E'Status
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'Status)
    -> [Char] -> Either [Char] E'Status
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'Status: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    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 (Int -> E'Status2 -> ShowS
    [E'Status2] -> ShowS
    E'Status2 -> [Char]
    (Int -> E'Status2 -> ShowS)
    -> (E'Status2 -> [Char])
    -> ([E'Status2] -> ShowS)
    -> Show E'Status2
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> E'Status2 -> ShowS
    showsPrec :: Int -> E'Status2 -> ShowS
    $cshow :: E'Status2 -> [Char]
    show :: E'Status2 -> [Char]
    $cshowList :: [E'Status2] -> ShowS
    showList :: [E'Status2] -> ShowS
    P.Show, E'Status2 -> E'Status2 -> Bool
    (E'Status2 -> E'Status2 -> Bool)
    -> (E'Status2 -> E'Status2 -> Bool) -> Eq E'Status2
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: E'Status2 -> E'Status2 -> Bool
    == :: E'Status2 -> E'Status2 -> Bool
    $c/= :: E'Status2 -> E'Status2 -> Bool
    /= :: E'Status2 -> E'Status2 -> Bool
    P.Eq, P.Typeable, Eq E'Status2
    Eq E'Status2
    -> (E'Status2 -> E'Status2 -> Ordering)
    -> (E'Status2 -> E'Status2 -> Bool)
    -> (E'Status2 -> E'Status2 -> Bool)
    -> (E'Status2 -> E'Status2 -> Bool)
    -> (E'Status2 -> E'Status2 -> Bool)
    -> (E'Status2 -> E'Status2 -> E'Status2)
    -> (E'Status2 -> E'Status2 -> E'Status2)
    -> Ord E'Status2
    E'Status2 -> E'Status2 -> Bool
    E'Status2 -> E'Status2 -> Ordering
    E'Status2 -> E'Status2 -> E'Status2
    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
    $ccompare :: E'Status2 -> E'Status2 -> Ordering
    compare :: E'Status2 -> E'Status2 -> Ordering
    $c< :: E'Status2 -> E'Status2 -> Bool
    < :: E'Status2 -> E'Status2 -> Bool
    $c<= :: E'Status2 -> E'Status2 -> Bool
    <= :: E'Status2 -> E'Status2 -> Bool
    $c> :: E'Status2 -> E'Status2 -> Bool
    > :: E'Status2 -> E'Status2 -> Bool
    $c>= :: E'Status2 -> E'Status2 -> Bool
    >= :: E'Status2 -> E'Status2 -> Bool
    $cmax :: E'Status2 -> E'Status2 -> E'Status2
    max :: E'Status2 -> E'Status2 -> E'Status2
    $cmin :: E'Status2 -> E'Status2 -> E'Status2
    min :: E'Status2 -> E'Status2 -> E'Status2
    P.Ord, E'Status2
    E'Status2 -> E'Status2 -> Bounded E'Status2
    forall a. a -> a -> Bounded a
    $cminBound :: E'Status2
    minBound :: E'Status2
    $cmaxBound :: E'Status2
    maxBound :: E'Status2
    P.Bounded, Int -> E'Status2
    E'Status2 -> Int
    E'Status2 -> [E'Status2]
    E'Status2 -> E'Status2
    E'Status2 -> E'Status2 -> [E'Status2]
    E'Status2 -> E'Status2 -> E'Status2 -> [E'Status2]
    (E'Status2 -> E'Status2)
    -> (E'Status2 -> E'Status2)
    -> (Int -> E'Status2)
    -> (E'Status2 -> Int)
    -> (E'Status2 -> [E'Status2])
    -> (E'Status2 -> E'Status2 -> [E'Status2])
    -> (E'Status2 -> E'Status2 -> [E'Status2])
    -> (E'Status2 -> E'Status2 -> E'Status2 -> [E'Status2])
    -> Enum E'Status2
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: E'Status2 -> E'Status2
    succ :: E'Status2 -> E'Status2
    $cpred :: E'Status2 -> E'Status2
    pred :: E'Status2 -> E'Status2
    $ctoEnum :: Int -> E'Status2
    toEnum :: Int -> E'Status2
    $cfromEnum :: E'Status2 -> Int
    fromEnum :: E'Status2 -> Int
    $cenumFrom :: E'Status2 -> [E'Status2]
    enumFrom :: E'Status2 -> [E'Status2]
    $cenumFromThen :: E'Status2 -> E'Status2 -> [E'Status2]
    enumFromThen :: E'Status2 -> E'Status2 -> [E'Status2]
    $cenumFromTo :: E'Status2 -> E'Status2 -> [E'Status2]
    enumFromTo :: E'Status2 -> E'Status2 -> [E'Status2]
    $cenumFromThenTo :: E'Status2 -> E'Status2 -> E'Status2 -> [E'Status2]
    enumFromThenTo :: E'Status2 -> E'Status2 -> E'Status2 -> [E'Status2]
    P.Enum)

    instance A.ToJSON E'Status2 where toJSON :: E'Status2 -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value) -> (E'Status2 -> Text) -> E'Status2 -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Status2 -> Text
    fromE'Status2
    instance A.FromJSON E'Status2 where parseJSON :: Value -> Parser E'Status2
    parseJSON Value
    o = ([Char] -> Parser E'Status2)
    -> (E'Status2 -> Parser E'Status2)
    -> Either [Char] E'Status2
    -> Parser E'Status2
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser E'Status2
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (E'Status2 -> Parser E'Status2
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (E'Status2 -> Parser E'Status2)
    -> (E'Status2 -> E'Status2) -> E'Status2 -> Parser E'Status2
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Status2 -> E'Status2
    forall a. a -> a
    P.id) (Either [Char] E'Status2 -> Parser E'Status2)
    -> (Text -> Either [Char] E'Status2) -> Text -> Parser E'Status2
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'Status2
    toE'Status2 (Text -> Parser E'Status2) -> Parser Text -> Parser E'Status2
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData E'Status2 where toQueryParam :: E'Status2 -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text) -> (E'Status2 -> Text) -> E'Status2 -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . E'Status2 -> Text
    fromE'Status2
    instance WH.FromHttpApiData E'Status2 where parseQueryParam :: Text -> Either Text E'Status2
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text E'Status2) -> Either Text E'Status2
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] E'Status2 -> Either Text E'Status2
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] E'Status2 -> Either Text E'Status2)
    -> (Text -> Either [Char] E'Status2)
    -> Text
    -> Either Text E'Status2
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] E'Status2
    toE'Status2
    instance MimeRender MimeMultipartFormData E'Status2 where mimeRender :: Proxy MimeMultipartFormData -> E'Status2 -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = E'Status2 -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'E'Status2' enum
    fromE'Status2 :: E'Status2 -> Text
    fromE'Status2 :: E'Status2 -> Text
    fromE'Status2 = \case
      E'Status2
    E'Status2'Available -> Text
    "available"
      E'Status2
    E'Status2'Pending -> Text
    "pending"
      E'Status2
    E'Status2'Sold -> Text
    "sold"

    -- | parse 'E'Status2' enum
    toE'Status2 :: Text -> P.Either String E'Status2
    toE'Status2 :: Text -> Either [Char] E'Status2
    toE'Status2 = \case
      Text
    "available" -> E'Status2 -> Either [Char] E'Status2
    forall a b. b -> Either a b
    P.Right E'Status2
    E'Status2'Available
      Text
    "pending" -> E'Status2 -> Either [Char] E'Status2
    forall a b. b -> Either a b
    P.Right E'Status2
    E'Status2'Pending
      Text
    "sold" -> E'Status2 -> Either [Char] E'Status2
    forall a b. b -> Either a b
    P.Right E'Status2
    E'Status2'Sold
      Text
    s -> [Char] -> Either [Char] E'Status2
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] E'Status2)
    -> [Char] -> Either [Char] E'Status2
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toE'Status2: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- ** EnumClass

    -- | Enum of 'Text'
    data EnumClass
      = EnumClass'_abc -- ^ @"_abc"@
      | EnumClass'_efg -- ^ @"-efg"@
      | EnumClass'_xyz -- ^ @"(xyz)"@
      deriving (Int -> EnumClass -> ShowS
    [EnumClass] -> ShowS
    EnumClass -> [Char]
    (Int -> EnumClass -> ShowS)
    -> (EnumClass -> [Char])
    -> ([EnumClass] -> ShowS)
    -> Show EnumClass
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EnumClass -> ShowS
    showsPrec :: Int -> EnumClass -> ShowS
    $cshow :: EnumClass -> [Char]
    show :: EnumClass -> [Char]
    $cshowList :: [EnumClass] -> ShowS
    showList :: [EnumClass] -> ShowS
    P.Show, EnumClass -> EnumClass -> Bool
    (EnumClass -> EnumClass -> Bool)
    -> (EnumClass -> EnumClass -> Bool) -> Eq EnumClass
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EnumClass -> EnumClass -> Bool
    == :: EnumClass -> EnumClass -> Bool
    $c/= :: EnumClass -> EnumClass -> Bool
    /= :: EnumClass -> EnumClass -> Bool
    P.Eq, P.Typeable, Eq EnumClass
    Eq EnumClass
    -> (EnumClass -> EnumClass -> Ordering)
    -> (EnumClass -> EnumClass -> Bool)
    -> (EnumClass -> EnumClass -> Bool)
    -> (EnumClass -> EnumClass -> Bool)
    -> (EnumClass -> EnumClass -> Bool)
    -> (EnumClass -> EnumClass -> EnumClass)
    -> (EnumClass -> EnumClass -> EnumClass)
    -> Ord EnumClass
    EnumClass -> EnumClass -> Bool
    EnumClass -> EnumClass -> Ordering
    EnumClass -> EnumClass -> EnumClass
    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
    $ccompare :: EnumClass -> EnumClass -> Ordering
    compare :: EnumClass -> EnumClass -> Ordering
    $c< :: EnumClass -> EnumClass -> Bool
    < :: EnumClass -> EnumClass -> Bool
    $c<= :: EnumClass -> EnumClass -> Bool
    <= :: EnumClass -> EnumClass -> Bool
    $c> :: EnumClass -> EnumClass -> Bool
    > :: EnumClass -> EnumClass -> Bool
    $c>= :: EnumClass -> EnumClass -> Bool
    >= :: EnumClass -> EnumClass -> Bool
    $cmax :: EnumClass -> EnumClass -> EnumClass
    max :: EnumClass -> EnumClass -> EnumClass
    $cmin :: EnumClass -> EnumClass -> EnumClass
    min :: EnumClass -> EnumClass -> EnumClass
    P.Ord, EnumClass
    EnumClass -> EnumClass -> Bounded EnumClass
    forall a. a -> a -> Bounded a
    $cminBound :: EnumClass
    minBound :: EnumClass
    $cmaxBound :: EnumClass
    maxBound :: EnumClass
    P.Bounded, Int -> EnumClass
    EnumClass -> Int
    EnumClass -> [EnumClass]
    EnumClass -> EnumClass
    EnumClass -> EnumClass -> [EnumClass]
    EnumClass -> EnumClass -> EnumClass -> [EnumClass]
    (EnumClass -> EnumClass)
    -> (EnumClass -> EnumClass)
    -> (Int -> EnumClass)
    -> (EnumClass -> Int)
    -> (EnumClass -> [EnumClass])
    -> (EnumClass -> EnumClass -> [EnumClass])
    -> (EnumClass -> EnumClass -> [EnumClass])
    -> (EnumClass -> EnumClass -> EnumClass -> [EnumClass])
    -> Enum EnumClass
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: EnumClass -> EnumClass
    succ :: EnumClass -> EnumClass
    $cpred :: EnumClass -> EnumClass
    pred :: EnumClass -> EnumClass
    $ctoEnum :: Int -> EnumClass
    toEnum :: Int -> EnumClass
    $cfromEnum :: EnumClass -> Int
    fromEnum :: EnumClass -> Int
    $cenumFrom :: EnumClass -> [EnumClass]
    enumFrom :: EnumClass -> [EnumClass]
    $cenumFromThen :: EnumClass -> EnumClass -> [EnumClass]
    enumFromThen :: EnumClass -> EnumClass -> [EnumClass]
    $cenumFromTo :: EnumClass -> EnumClass -> [EnumClass]
    enumFromTo :: EnumClass -> EnumClass -> [EnumClass]
    $cenumFromThenTo :: EnumClass -> EnumClass -> EnumClass -> [EnumClass]
    enumFromThenTo :: EnumClass -> EnumClass -> EnumClass -> [EnumClass]
    P.Enum)

    instance A.ToJSON EnumClass where toJSON :: EnumClass -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value) -> (EnumClass -> Text) -> EnumClass -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EnumClass -> Text
    fromEnumClass
    instance A.FromJSON EnumClass where parseJSON :: Value -> Parser EnumClass
    parseJSON Value
    o = ([Char] -> Parser EnumClass)
    -> (EnumClass -> Parser EnumClass)
    -> Either [Char] EnumClass
    -> Parser EnumClass
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser EnumClass
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (EnumClass -> Parser EnumClass
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (EnumClass -> Parser EnumClass)
    -> (EnumClass -> EnumClass) -> EnumClass -> Parser EnumClass
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EnumClass -> EnumClass
    forall a. a -> a
    P.id) (Either [Char] EnumClass -> Parser EnumClass)
    -> (Text -> Either [Char] EnumClass) -> Text -> Parser EnumClass
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] EnumClass
    toEnumClass (Text -> Parser EnumClass) -> Parser Text -> Parser EnumClass
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData EnumClass where toQueryParam :: EnumClass -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text) -> (EnumClass -> Text) -> EnumClass -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EnumClass -> Text
    fromEnumClass
    instance WH.FromHttpApiData EnumClass where parseQueryParam :: Text -> Either Text EnumClass
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text EnumClass) -> Either Text EnumClass
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] EnumClass -> Either Text EnumClass
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] EnumClass -> Either Text EnumClass)
    -> (Text -> Either [Char] EnumClass)
    -> Text
    -> Either Text EnumClass
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] EnumClass
    toEnumClass
    instance MimeRender MimeMultipartFormData EnumClass where mimeRender :: Proxy MimeMultipartFormData -> EnumClass -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = EnumClass -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'EnumClass' enum
    fromEnumClass :: EnumClass -> Text
    fromEnumClass :: EnumClass -> Text
    fromEnumClass = \case
      EnumClass
    EnumClass'_abc -> Text
    "_abc"
      EnumClass
    EnumClass'_efg -> Text
    "-efg"
      EnumClass
    EnumClass'_xyz -> Text
    "(xyz)"

    -- | parse 'EnumClass' enum
    toEnumClass :: Text -> P.Either String EnumClass
    toEnumClass :: Text -> Either [Char] EnumClass
    toEnumClass = \case
      Text
    "_abc" -> EnumClass -> Either [Char] EnumClass
    forall a b. b -> Either a b
    P.Right EnumClass
    EnumClass'_abc
      Text
    "-efg" -> EnumClass -> Either [Char] EnumClass
    forall a b. b -> Either a b
    P.Right EnumClass
    EnumClass'_efg
      Text
    "(xyz)" -> EnumClass -> Either [Char] EnumClass
    forall a b. b -> Either a b
    P.Right EnumClass
    EnumClass'_xyz
      Text
    s -> [Char] -> Either [Char] EnumClass
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] EnumClass)
    -> [Char] -> Either [Char] EnumClass
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toEnumClass: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- ** OuterEnum

    -- | Enum of 'Text'
    data OuterEnum
      = OuterEnum'Placed -- ^ @"placed"@
      | OuterEnum'Approved -- ^ @"approved"@
      | OuterEnum'Delivered -- ^ @"delivered"@
      deriving (Int -> OuterEnum -> ShowS
    [OuterEnum] -> ShowS
    OuterEnum -> [Char]
    (Int -> OuterEnum -> ShowS)
    -> (OuterEnum -> [Char])
    -> ([OuterEnum] -> ShowS)
    -> Show OuterEnum
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OuterEnum -> ShowS
    showsPrec :: Int -> OuterEnum -> ShowS
    $cshow :: OuterEnum -> [Char]
    show :: OuterEnum -> [Char]
    $cshowList :: [OuterEnum] -> ShowS
    showList :: [OuterEnum] -> ShowS
    P.Show, OuterEnum -> OuterEnum -> Bool
    (OuterEnum -> OuterEnum -> Bool)
    -> (OuterEnum -> OuterEnum -> Bool) -> Eq OuterEnum
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OuterEnum -> OuterEnum -> Bool
    == :: OuterEnum -> OuterEnum -> Bool
    $c/= :: OuterEnum -> OuterEnum -> Bool
    /= :: OuterEnum -> OuterEnum -> Bool
    P.Eq, P.Typeable, Eq OuterEnum
    Eq OuterEnum
    -> (OuterEnum -> OuterEnum -> Ordering)
    -> (OuterEnum -> OuterEnum -> Bool)
    -> (OuterEnum -> OuterEnum -> Bool)
    -> (OuterEnum -> OuterEnum -> Bool)
    -> (OuterEnum -> OuterEnum -> Bool)
    -> (OuterEnum -> OuterEnum -> OuterEnum)
    -> (OuterEnum -> OuterEnum -> OuterEnum)
    -> Ord OuterEnum
    OuterEnum -> OuterEnum -> Bool
    OuterEnum -> OuterEnum -> Ordering
    OuterEnum -> OuterEnum -> OuterEnum
    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
    $ccompare :: OuterEnum -> OuterEnum -> Ordering
    compare :: OuterEnum -> OuterEnum -> Ordering
    $c< :: OuterEnum -> OuterEnum -> Bool
    < :: OuterEnum -> OuterEnum -> Bool
    $c<= :: OuterEnum -> OuterEnum -> Bool
    <= :: OuterEnum -> OuterEnum -> Bool
    $c> :: OuterEnum -> OuterEnum -> Bool
    > :: OuterEnum -> OuterEnum -> Bool
    $c>= :: OuterEnum -> OuterEnum -> Bool
    >= :: OuterEnum -> OuterEnum -> Bool
    $cmax :: OuterEnum -> OuterEnum -> OuterEnum
    max :: OuterEnum -> OuterEnum -> OuterEnum
    $cmin :: OuterEnum -> OuterEnum -> OuterEnum
    min :: OuterEnum -> OuterEnum -> OuterEnum
    P.Ord, OuterEnum
    OuterEnum -> OuterEnum -> Bounded OuterEnum
    forall a. a -> a -> Bounded a
    $cminBound :: OuterEnum
    minBound :: OuterEnum
    $cmaxBound :: OuterEnum
    maxBound :: OuterEnum
    P.Bounded, Int -> OuterEnum
    OuterEnum -> Int
    OuterEnum -> [OuterEnum]
    OuterEnum -> OuterEnum
    OuterEnum -> OuterEnum -> [OuterEnum]
    OuterEnum -> OuterEnum -> OuterEnum -> [OuterEnum]
    (OuterEnum -> OuterEnum)
    -> (OuterEnum -> OuterEnum)
    -> (Int -> OuterEnum)
    -> (OuterEnum -> Int)
    -> (OuterEnum -> [OuterEnum])
    -> (OuterEnum -> OuterEnum -> [OuterEnum])
    -> (OuterEnum -> OuterEnum -> [OuterEnum])
    -> (OuterEnum -> OuterEnum -> OuterEnum -> [OuterEnum])
    -> Enum OuterEnum
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: OuterEnum -> OuterEnum
    succ :: OuterEnum -> OuterEnum
    $cpred :: OuterEnum -> OuterEnum
    pred :: OuterEnum -> OuterEnum
    $ctoEnum :: Int -> OuterEnum
    toEnum :: Int -> OuterEnum
    $cfromEnum :: OuterEnum -> Int
    fromEnum :: OuterEnum -> Int
    $cenumFrom :: OuterEnum -> [OuterEnum]
    enumFrom :: OuterEnum -> [OuterEnum]
    $cenumFromThen :: OuterEnum -> OuterEnum -> [OuterEnum]
    enumFromThen :: OuterEnum -> OuterEnum -> [OuterEnum]
    $cenumFromTo :: OuterEnum -> OuterEnum -> [OuterEnum]
    enumFromTo :: OuterEnum -> OuterEnum -> [OuterEnum]
    $cenumFromThenTo :: OuterEnum -> OuterEnum -> OuterEnum -> [OuterEnum]
    enumFromThenTo :: OuterEnum -> OuterEnum -> OuterEnum -> [OuterEnum]
    P.Enum)

    instance A.ToJSON OuterEnum where toJSON :: OuterEnum -> Value
    toJSON = Text -> Value
    forall a. ToJSON a => a -> Value
    A.toJSON (Text -> Value) -> (OuterEnum -> Text) -> OuterEnum -> Value
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . OuterEnum -> Text
    fromOuterEnum
    instance A.FromJSON OuterEnum where parseJSON :: Value -> Parser OuterEnum
    parseJSON Value
    o = ([Char] -> Parser OuterEnum)
    -> (OuterEnum -> Parser OuterEnum)
    -> Either [Char] OuterEnum
    -> Parser OuterEnum
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    P.either [Char] -> Parser OuterEnum
    forall a. [Char] -> Parser a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    P.fail (OuterEnum -> Parser OuterEnum
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (OuterEnum -> Parser OuterEnum)
    -> (OuterEnum -> OuterEnum) -> OuterEnum -> Parser OuterEnum
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . OuterEnum -> OuterEnum
    forall a. a -> a
    P.id) (Either [Char] OuterEnum -> Parser OuterEnum)
    -> (Text -> Either [Char] OuterEnum) -> Text -> Parser OuterEnum
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] OuterEnum
    toOuterEnum (Text -> Parser OuterEnum) -> Parser Text -> Parser OuterEnum
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Value -> Parser Text
    forall a. FromJSON a => Value -> Parser a
    A.parseJSON Value
    o
    instance WH.ToHttpApiData OuterEnum where toQueryParam :: OuterEnum -> Text
    toQueryParam = Text -> Text
    forall a. ToHttpApiData a => a -> Text
    WH.toQueryParam (Text -> Text) -> (OuterEnum -> Text) -> OuterEnum -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . OuterEnum -> Text
    fromOuterEnum
    instance WH.FromHttpApiData OuterEnum where parseQueryParam :: Text -> Either Text OuterEnum
    parseQueryParam Text
    o = Text -> Either Text Text
    forall a. FromHttpApiData a => Text -> Either Text a
    WH.parseQueryParam Text
    o Either Text Text
    -> (Text -> Either Text OuterEnum) -> Either Text OuterEnum
    forall a b. Either Text a -> (a -> Either Text b) -> Either Text b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ([Char] -> Text)
    -> Either [Char] OuterEnum -> Either Text OuterEnum
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    P.left [Char] -> Text
    T.pack (Either [Char] OuterEnum -> Either Text OuterEnum)
    -> (Text -> Either [Char] OuterEnum)
    -> Text
    -> Either Text OuterEnum
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Either [Char] OuterEnum
    toOuterEnum
    instance MimeRender MimeMultipartFormData OuterEnum where mimeRender :: Proxy MimeMultipartFormData -> OuterEnum -> ByteString
    mimeRender Proxy MimeMultipartFormData
    _ = OuterEnum -> ByteString
    forall a. ToHttpApiData a => a -> ByteString
    mimeRenderDefaultMultipartFormData

    -- | unwrap 'OuterEnum' enum
    fromOuterEnum :: OuterEnum -> Text
    fromOuterEnum :: OuterEnum -> Text
    fromOuterEnum = \case
      OuterEnum
    OuterEnum'Placed -> Text
    "placed"
      OuterEnum
    OuterEnum'Approved -> Text
    "approved"
      OuterEnum
    OuterEnum'Delivered -> Text
    "delivered"

    -- | parse 'OuterEnum' enum
    toOuterEnum :: Text -> P.Either String OuterEnum
    toOuterEnum :: Text -> Either [Char] OuterEnum
    toOuterEnum = \case
      Text
    "placed" -> OuterEnum -> Either [Char] OuterEnum
    forall a b. b -> Either a b
    P.Right OuterEnum
    OuterEnum'Placed
      Text
    "approved" -> OuterEnum -> Either [Char] OuterEnum
    forall a b. b -> Either a b
    P.Right OuterEnum
    OuterEnum'Approved
      Text
    "delivered" -> OuterEnum -> Either [Char] OuterEnum
    forall a b. b -> Either a b
    P.Right OuterEnum
    OuterEnum'Delivered
      Text
    s -> [Char] -> Either [Char] OuterEnum
    forall a b. a -> Either a b
    P.Left ([Char] -> Either [Char] OuterEnum)
    -> [Char] -> Either [Char] OuterEnum
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "toOuterEnum: enum parse failure: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    P.++ Text -> [Char]
    forall a. Show a => a -> [Char]
    P.show Text
    s

    -- * Auth Methods

    -- ** AuthOAuthPetstoreAuth
    data AuthOAuthPetstoreAuth =
      AuthOAuthPetstoreAuth Text -- ^ secret
      deriving (AuthOAuthPetstoreAuth -> AuthOAuthPetstoreAuth -> Bool
    (AuthOAuthPetstoreAuth -> AuthOAuthPetstoreAuth -> Bool)
    -> (AuthOAuthPetstoreAuth -> AuthOAuthPetstoreAuth -> Bool)
    -> Eq AuthOAuthPetstoreAuth
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AuthOAuthPetstoreAuth -> AuthOAuthPetstoreAuth -> Bool
    == :: AuthOAuthPetstoreAuth -> AuthOAuthPetstoreAuth -> Bool
    $c/= :: AuthOAuthPetstoreAuth -> AuthOAuthPetstoreAuth -> Bool
    /= :: AuthOAuthPetstoreAuth -> AuthOAuthPetstoreAuth -> Bool
    P.Eq, Int -> AuthOAuthPetstoreAuth -> ShowS
    [AuthOAuthPetstoreAuth] -> ShowS
    AuthOAuthPetstoreAuth -> [Char]
    (Int -> AuthOAuthPetstoreAuth -> ShowS)
    -> (AuthOAuthPetstoreAuth -> [Char])
    -> ([AuthOAuthPetstoreAuth] -> ShowS)
    -> Show AuthOAuthPetstoreAuth
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AuthOAuthPetstoreAuth -> ShowS
    showsPrec :: Int -> AuthOAuthPetstoreAuth -> ShowS
    $cshow :: AuthOAuthPetstoreAuth -> [Char]
    show :: AuthOAuthPetstoreAuth -> [Char]
    $cshowList :: [AuthOAuthPetstoreAuth] -> ShowS
    showList :: [AuthOAuthPetstoreAuth] -> ShowS
    P.Show, P.Typeable)

    instance AuthMethod AuthOAuthPetstoreAuth where
      applyAuthMethod :: forall req contentType res accept.
    OpenAPIPetstoreConfig
    -> AuthOAuthPetstoreAuth
    -> OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    applyAuthMethod OpenAPIPetstoreConfig
    _ a :: AuthOAuthPetstoreAuth
    a@(AuthOAuthPetstoreAuth Text
    secret) OpenAPIPetstoreRequest req contentType res accept
    req =
        OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    forall a. a -> IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    P.pure (OpenAPIPetstoreRequest req contentType res accept
     -> IO (OpenAPIPetstoreRequest req contentType res accept))
    -> OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    forall a b. (a -> b) -> a -> b
    $
        if (AuthOAuthPetstoreAuth -> TypeRep
    forall a. Typeable a => a -> TypeRep
    P.typeOf AuthOAuthPetstoreAuth
    a TypeRep -> [TypeRep] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `P.elem` OpenAPIPetstoreRequest req contentType res accept -> [TypeRep]
    forall req contentType res accept.
    OpenAPIPetstoreRequest req contentType res accept -> [TypeRep]
    rAuthTypes OpenAPIPetstoreRequest req contentType res accept
    req)
          then OpenAPIPetstoreRequest req contentType res accept
    req OpenAPIPetstoreRequest req contentType res accept
    -> [Header] -> OpenAPIPetstoreRequest req contentType res accept
    forall req contentType res accept.
    OpenAPIPetstoreRequest req contentType res accept
    -> [Header] -> OpenAPIPetstoreRequest req contentType res accept
    `setHeader` (HeaderName, Text) -> [Header]
    forall a. ToHttpApiData a => (HeaderName, a) -> [Header]
    toHeader (HeaderName
    "Authorization", Text
    "Bearer " Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    secret)
               OpenAPIPetstoreRequest req contentType res accept
    -> (OpenAPIPetstoreRequest req contentType res accept
        -> OpenAPIPetstoreRequest req contentType res accept)
    -> OpenAPIPetstoreRequest req contentType res accept
    forall a b. a -> (a -> b) -> b
    & ASetter
      (OpenAPIPetstoreRequest req contentType res accept)
      (OpenAPIPetstoreRequest req contentType res accept)
      [TypeRep]
      [TypeRep]
    -> ([TypeRep] -> [TypeRep])
    -> OpenAPIPetstoreRequest req contentType res accept
    -> OpenAPIPetstoreRequest req contentType res accept
    forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
    L.over ASetter
      (OpenAPIPetstoreRequest req contentType res accept)
      (OpenAPIPetstoreRequest req contentType res accept)
      [TypeRep]
      [TypeRep]
    forall req contentType res accept (f :: * -> *).
    Functor f =>
    ([TypeRep] -> f [TypeRep])
    -> OpenAPIPetstoreRequest req contentType res accept
    -> f (OpenAPIPetstoreRequest req contentType res accept)
    rAuthTypesL ((TypeRep -> Bool) -> [TypeRep] -> [TypeRep]
    forall a. (a -> Bool) -> [a] -> [a]
    P.filter (TypeRep -> TypeRep -> Bool
    forall a. Eq a => a -> a -> Bool
    /= AuthOAuthPetstoreAuth -> TypeRep
    forall a. Typeable a => a -> TypeRep
    P.typeOf AuthOAuthPetstoreAuth
    a))
          else OpenAPIPetstoreRequest req contentType res accept
    req

    -- ** AuthApiKeyApiKey
    data AuthApiKeyApiKey =
      AuthApiKeyApiKey Text -- ^ secret
      deriving (AuthApiKeyApiKey -> AuthApiKeyApiKey -> Bool
    (AuthApiKeyApiKey -> AuthApiKeyApiKey -> Bool)
    -> (AuthApiKeyApiKey -> AuthApiKeyApiKey -> Bool)
    -> Eq AuthApiKeyApiKey
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AuthApiKeyApiKey -> AuthApiKeyApiKey -> Bool
    == :: AuthApiKeyApiKey -> AuthApiKeyApiKey -> Bool
    $c/= :: AuthApiKeyApiKey -> AuthApiKeyApiKey -> Bool
    /= :: AuthApiKeyApiKey -> AuthApiKeyApiKey -> Bool
    P.Eq, Int -> AuthApiKeyApiKey -> ShowS
    [AuthApiKeyApiKey] -> ShowS
    AuthApiKeyApiKey -> [Char]
    (Int -> AuthApiKeyApiKey -> ShowS)
    -> (AuthApiKeyApiKey -> [Char])
    -> ([AuthApiKeyApiKey] -> ShowS)
    -> Show AuthApiKeyApiKey
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AuthApiKeyApiKey -> ShowS
    showsPrec :: Int -> AuthApiKeyApiKey -> ShowS
    $cshow :: AuthApiKeyApiKey -> [Char]
    show :: AuthApiKeyApiKey -> [Char]
    $cshowList :: [AuthApiKeyApiKey] -> ShowS
    showList :: [AuthApiKeyApiKey] -> ShowS
    P.Show, P.Typeable)

    instance AuthMethod AuthApiKeyApiKey where
      applyAuthMethod :: forall req contentType res accept.
    OpenAPIPetstoreConfig
    -> AuthApiKeyApiKey
    -> OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    applyAuthMethod OpenAPIPetstoreConfig
    _ a :: AuthApiKeyApiKey
    a@(AuthApiKeyApiKey Text
    secret) OpenAPIPetstoreRequest req contentType res accept
    req =
        OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    forall a. a -> IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    P.pure (OpenAPIPetstoreRequest req contentType res accept
     -> IO (OpenAPIPetstoreRequest req contentType res accept))
    -> OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    forall a b. (a -> b) -> a -> b
    $
        if (AuthApiKeyApiKey -> TypeRep
    forall a. Typeable a => a -> TypeRep
    P.typeOf AuthApiKeyApiKey
    a TypeRep -> [TypeRep] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `P.elem` OpenAPIPetstoreRequest req contentType res accept -> [TypeRep]
    forall req contentType res accept.
    OpenAPIPetstoreRequest req contentType res accept -> [TypeRep]
    rAuthTypes OpenAPIPetstoreRequest req contentType res accept
    req)
          then OpenAPIPetstoreRequest req contentType res accept
    req OpenAPIPetstoreRequest req contentType res accept
    -> [Header] -> OpenAPIPetstoreRequest req contentType res accept
    forall req contentType res accept.
    OpenAPIPetstoreRequest req contentType res accept
    -> [Header] -> OpenAPIPetstoreRequest req contentType res accept
    `setHeader` (HeaderName, Text) -> [Header]
    forall a. ToHttpApiData a => (HeaderName, a) -> [Header]
    toHeader (HeaderName
    "api_key", Text
    secret)
               OpenAPIPetstoreRequest req contentType res accept
    -> (OpenAPIPetstoreRequest req contentType res accept
        -> OpenAPIPetstoreRequest req contentType res accept)
    -> OpenAPIPetstoreRequest req contentType res accept
    forall a b. a -> (a -> b) -> b
    & ASetter
      (OpenAPIPetstoreRequest req contentType res accept)
      (OpenAPIPetstoreRequest req contentType res accept)
      [TypeRep]
      [TypeRep]
    -> ([TypeRep] -> [TypeRep])
    -> OpenAPIPetstoreRequest req contentType res accept
    -> OpenAPIPetstoreRequest req contentType res accept
    forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
    L.over ASetter
      (OpenAPIPetstoreRequest req contentType res accept)
      (OpenAPIPetstoreRequest req contentType res accept)
      [TypeRep]
      [TypeRep]
    forall req contentType res accept (f :: * -> *).
    Functor f =>
    ([TypeRep] -> f [TypeRep])
    -> OpenAPIPetstoreRequest req contentType res accept
    -> f (OpenAPIPetstoreRequest req contentType res accept)
    rAuthTypesL ((TypeRep -> Bool) -> [TypeRep] -> [TypeRep]
    forall a. (a -> Bool) -> [a] -> [a]
    P.filter (TypeRep -> TypeRep -> Bool
    forall a. Eq a => a -> a -> Bool
    /= AuthApiKeyApiKey -> TypeRep
    forall a. Typeable a => a -> TypeRep
    P.typeOf AuthApiKeyApiKey
    a))
          else OpenAPIPetstoreRequest req contentType res accept
    req

    -- ** AuthApiKeyApiKeyQuery
    data AuthApiKeyApiKeyQuery =
      AuthApiKeyApiKeyQuery Text -- ^ secret
      deriving (AuthApiKeyApiKeyQuery -> AuthApiKeyApiKeyQuery -> Bool
    (AuthApiKeyApiKeyQuery -> AuthApiKeyApiKeyQuery -> Bool)
    -> (AuthApiKeyApiKeyQuery -> AuthApiKeyApiKeyQuery -> Bool)
    -> Eq AuthApiKeyApiKeyQuery
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AuthApiKeyApiKeyQuery -> AuthApiKeyApiKeyQuery -> Bool
    == :: AuthApiKeyApiKeyQuery -> AuthApiKeyApiKeyQuery -> Bool
    $c/= :: AuthApiKeyApiKeyQuery -> AuthApiKeyApiKeyQuery -> Bool
    /= :: AuthApiKeyApiKeyQuery -> AuthApiKeyApiKeyQuery -> Bool
    P.Eq, Int -> AuthApiKeyApiKeyQuery -> ShowS
    [AuthApiKeyApiKeyQuery] -> ShowS
    AuthApiKeyApiKeyQuery -> [Char]
    (Int -> AuthApiKeyApiKeyQuery -> ShowS)
    -> (AuthApiKeyApiKeyQuery -> [Char])
    -> ([AuthApiKeyApiKeyQuery] -> ShowS)
    -> Show AuthApiKeyApiKeyQuery
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AuthApiKeyApiKeyQuery -> ShowS
    showsPrec :: Int -> AuthApiKeyApiKeyQuery -> ShowS
    $cshow :: AuthApiKeyApiKeyQuery -> [Char]
    show :: AuthApiKeyApiKeyQuery -> [Char]
    $cshowList :: [AuthApiKeyApiKeyQuery] -> ShowS
    showList :: [AuthApiKeyApiKeyQuery] -> ShowS
    P.Show, P.Typeable)

    instance AuthMethod AuthApiKeyApiKeyQuery where
      applyAuthMethod :: forall req contentType res accept.
    OpenAPIPetstoreConfig
    -> AuthApiKeyApiKeyQuery
    -> OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    applyAuthMethod OpenAPIPetstoreConfig
    _ a :: AuthApiKeyApiKeyQuery
    a@(AuthApiKeyApiKeyQuery Text
    secret) OpenAPIPetstoreRequest req contentType res accept
    req =
        OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    forall a. a -> IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    P.pure (OpenAPIPetstoreRequest req contentType res accept
     -> IO (OpenAPIPetstoreRequest req contentType res accept))
    -> OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    forall a b. (a -> b) -> a -> b
    $
        if (AuthApiKeyApiKeyQuery -> TypeRep
    forall a. Typeable a => a -> TypeRep
    P.typeOf AuthApiKeyApiKeyQuery
    a TypeRep -> [TypeRep] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `P.elem` OpenAPIPetstoreRequest req contentType res accept -> [TypeRep]
    forall req contentType res accept.
    OpenAPIPetstoreRequest req contentType res accept -> [TypeRep]
    rAuthTypes OpenAPIPetstoreRequest req contentType res accept
    req)
          then OpenAPIPetstoreRequest req contentType res accept
    req OpenAPIPetstoreRequest req contentType res accept
    -> [QueryItem] -> OpenAPIPetstoreRequest req contentType res accept
    forall req contentType res accept.
    OpenAPIPetstoreRequest req contentType res accept
    -> [QueryItem] -> OpenAPIPetstoreRequest req contentType res accept
    `setQuery` (ByteString, Maybe Text) -> [QueryItem]
    forall a. ToHttpApiData a => (ByteString, Maybe a) -> [QueryItem]
    toQuery (ByteString
    "api_key_query", Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    secret)
               OpenAPIPetstoreRequest req contentType res accept
    -> (OpenAPIPetstoreRequest req contentType res accept
        -> OpenAPIPetstoreRequest req contentType res accept)
    -> OpenAPIPetstoreRequest req contentType res accept
    forall a b. a -> (a -> b) -> b
    & ASetter
      (OpenAPIPetstoreRequest req contentType res accept)
      (OpenAPIPetstoreRequest req contentType res accept)
      [TypeRep]
      [TypeRep]
    -> ([TypeRep] -> [TypeRep])
    -> OpenAPIPetstoreRequest req contentType res accept
    -> OpenAPIPetstoreRequest req contentType res accept
    forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
    L.over ASetter
      (OpenAPIPetstoreRequest req contentType res accept)
      (OpenAPIPetstoreRequest req contentType res accept)
      [TypeRep]
      [TypeRep]
    forall req contentType res accept (f :: * -> *).
    Functor f =>
    ([TypeRep] -> f [TypeRep])
    -> OpenAPIPetstoreRequest req contentType res accept
    -> f (OpenAPIPetstoreRequest req contentType res accept)
    rAuthTypesL ((TypeRep -> Bool) -> [TypeRep] -> [TypeRep]
    forall a. (a -> Bool) -> [a] -> [a]
    P.filter (TypeRep -> TypeRep -> Bool
    forall a. Eq a => a -> a -> Bool
    /= AuthApiKeyApiKeyQuery -> TypeRep
    forall a. Typeable a => a -> TypeRep
    P.typeOf AuthApiKeyApiKeyQuery
    a))
          else OpenAPIPetstoreRequest req contentType res accept
    req

    -- ** AuthBasicHttpBasicTest
    data AuthBasicHttpBasicTest =
      AuthBasicHttpBasicTest B.ByteString B.ByteString -- ^ username password
      deriving (AuthBasicHttpBasicTest -> AuthBasicHttpBasicTest -> Bool
    (AuthBasicHttpBasicTest -> AuthBasicHttpBasicTest -> Bool)
    -> (AuthBasicHttpBasicTest -> AuthBasicHttpBasicTest -> Bool)
    -> Eq AuthBasicHttpBasicTest
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AuthBasicHttpBasicTest -> AuthBasicHttpBasicTest -> Bool
    == :: AuthBasicHttpBasicTest -> AuthBasicHttpBasicTest -> Bool
    $c/= :: AuthBasicHttpBasicTest -> AuthBasicHttpBasicTest -> Bool
    /= :: AuthBasicHttpBasicTest -> AuthBasicHttpBasicTest -> Bool
    P.Eq, Int -> AuthBasicHttpBasicTest -> ShowS
    [AuthBasicHttpBasicTest] -> ShowS
    AuthBasicHttpBasicTest -> [Char]
    (Int -> AuthBasicHttpBasicTest -> ShowS)
    -> (AuthBasicHttpBasicTest -> [Char])
    -> ([AuthBasicHttpBasicTest] -> ShowS)
    -> Show AuthBasicHttpBasicTest
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AuthBasicHttpBasicTest -> ShowS
    showsPrec :: Int -> AuthBasicHttpBasicTest -> ShowS
    $cshow :: AuthBasicHttpBasicTest -> [Char]
    show :: AuthBasicHttpBasicTest -> [Char]
    $cshowList :: [AuthBasicHttpBasicTest] -> ShowS
    showList :: [AuthBasicHttpBasicTest] -> ShowS
    P.Show, P.Typeable)

    instance AuthMethod AuthBasicHttpBasicTest where
      applyAuthMethod :: forall req contentType res accept.
    OpenAPIPetstoreConfig
    -> AuthBasicHttpBasicTest
    -> OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    applyAuthMethod OpenAPIPetstoreConfig
    _ a :: AuthBasicHttpBasicTest
    a@(AuthBasicHttpBasicTest ByteString
    user ByteString
    pw) OpenAPIPetstoreRequest req contentType res accept
    req =
        OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    forall a. a -> IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    P.pure (OpenAPIPetstoreRequest req contentType res accept
     -> IO (OpenAPIPetstoreRequest req contentType res accept))
    -> OpenAPIPetstoreRequest req contentType res accept
    -> IO (OpenAPIPetstoreRequest req contentType res accept)
    forall a b. (a -> b) -> a -> b
    $
        if (AuthBasicHttpBasicTest -> TypeRep
    forall a. Typeable a => a -> TypeRep
    P.typeOf AuthBasicHttpBasicTest
    a TypeRep -> [TypeRep] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `P.elem` OpenAPIPetstoreRequest req contentType res accept -> [TypeRep]
    forall req contentType res accept.
    OpenAPIPetstoreRequest req contentType res accept -> [TypeRep]
    rAuthTypes OpenAPIPetstoreRequest req contentType res accept
    req)
          then OpenAPIPetstoreRequest req contentType res accept
    req OpenAPIPetstoreRequest req contentType res accept
    -> [Header] -> OpenAPIPetstoreRequest req contentType res accept
    forall req contentType res accept.
    OpenAPIPetstoreRequest req contentType res accept
    -> [Header] -> OpenAPIPetstoreRequest req contentType res accept
    `setHeader` (HeaderName, Text) -> [Header]
    forall a. ToHttpApiData a => (HeaderName, a) -> [Header]
    toHeader (HeaderName
    "Authorization", ByteString -> Text
    T.decodeUtf8 ByteString
    cred)
               OpenAPIPetstoreRequest req contentType res accept
    -> (OpenAPIPetstoreRequest req contentType res accept
        -> OpenAPIPetstoreRequest req contentType res accept)
    -> OpenAPIPetstoreRequest req contentType res accept
    forall a b. a -> (a -> b) -> b
    & ASetter
      (OpenAPIPetstoreRequest req contentType res accept)
      (OpenAPIPetstoreRequest req contentType res accept)
      [TypeRep]
      [TypeRep]
    -> ([TypeRep] -> [TypeRep])
    -> OpenAPIPetstoreRequest req contentType res accept
    -> OpenAPIPetstoreRequest req contentType res accept
    forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
    L.over ASetter
      (OpenAPIPetstoreRequest req contentType res accept)
      (OpenAPIPetstoreRequest req contentType res accept)
      [TypeRep]
      [TypeRep]
    forall req contentType res accept (f :: * -> *).
    Functor f =>
    ([TypeRep] -> f [TypeRep])
    -> OpenAPIPetstoreRequest req contentType res accept
    -> f (OpenAPIPetstoreRequest req contentType res accept)
    rAuthTypesL ((TypeRep -> Bool) -> [TypeRep] -> [TypeRep]
    forall a. (a -> Bool) -> [a] -> [a]
    P.filter (TypeRep -> TypeRep -> Bool
    forall a. Eq a => a -> a -> Bool
    /= AuthBasicHttpBasicTest -> TypeRep
    forall a. Typeable a => a -> TypeRep
    P.typeOf AuthBasicHttpBasicTest
    a))
          else OpenAPIPetstoreRequest req contentType res accept
    req
        where cred :: ByteString
    cred = ByteString -> ByteString -> ByteString
    BC.append ByteString
    "Basic " (ByteString -> ByteString
    B64.encode (ByteString -> ByteString) -> ByteString -> ByteString
    forall a b. (a -> b) -> a -> b
    $ [ByteString] -> ByteString
    BC.concat [ ByteString
    user, ByteString
    ":", ByteString
    pw ])