module SwaggerPetstore.API where
import SwaggerPetstore.Core
import SwaggerPetstore.MimeTypes
import SwaggerPetstore.Model as M
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.Map as Map
import qualified Data.Maybe as P
import qualified Data.Proxy as P (Proxy(..))
import qualified Data.Set as Set
import qualified Data.String as P
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.Encoding as TL
import qualified Data.Time as TI
import qualified GHC.Base as P (Alternative)
import qualified Lens.Micro as L
import qualified Network.HTTP.Client.MultipartFormData as NH
import qualified Network.HTTP.Media as ME
import qualified Network.HTTP.Types as NH
import qualified Web.FormUrlEncoded as WH
import qualified Web.HttpApiData as WH
import Data.Monoid ((<>))
import Data.Function ((&))
import Data.Text (Text)
import GHC.Base ((<|>))
import Prelude ((==),(/=),($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)
import qualified Prelude as P
testSpecialTags
:: (Consumes TestSpecialTags contentType, MimeRender contentType Client)
=> contentType
-> Client
-> SwaggerPetstoreRequest TestSpecialTags contentType Client
testSpecialTags _ body =
_mkRequest "PATCH" ["/another-fake/dummy"]
`setBodyParam` body
data TestSpecialTags
instance HasBodyParam TestSpecialTags Client
instance Consumes TestSpecialTags MimeJSON
instance Produces TestSpecialTags MimeJSON
fakeOuterBooleanSerialize
:: (Consumes FakeOuterBooleanSerialize contentType)
=> contentType
-> SwaggerPetstoreRequest FakeOuterBooleanSerialize contentType OuterBoolean
fakeOuterBooleanSerialize _ =
_mkRequest "POST" ["/fake/outer/boolean"]
data FakeOuterBooleanSerialize
instance HasBodyParam FakeOuterBooleanSerialize OuterBoolean
fakeOuterCompositeSerialize
:: (Consumes FakeOuterCompositeSerialize contentType)
=> contentType
-> SwaggerPetstoreRequest FakeOuterCompositeSerialize contentType OuterComposite
fakeOuterCompositeSerialize _ =
_mkRequest "POST" ["/fake/outer/composite"]
data FakeOuterCompositeSerialize
instance HasBodyParam FakeOuterCompositeSerialize OuterComposite
fakeOuterNumberSerialize
:: (Consumes FakeOuterNumberSerialize contentType)
=> contentType
-> SwaggerPetstoreRequest FakeOuterNumberSerialize contentType OuterNumber
fakeOuterNumberSerialize _ =
_mkRequest "POST" ["/fake/outer/number"]
data FakeOuterNumberSerialize
instance HasBodyParam FakeOuterNumberSerialize OuterNumber
fakeOuterStringSerialize
:: (Consumes FakeOuterStringSerialize contentType)
=> contentType
-> SwaggerPetstoreRequest FakeOuterStringSerialize contentType OuterString
fakeOuterStringSerialize _ =
_mkRequest "POST" ["/fake/outer/string"]
data FakeOuterStringSerialize
instance HasBodyParam FakeOuterStringSerialize OuterString
testClientModel
:: (Consumes TestClientModel contentType, MimeRender contentType Client)
=> contentType
-> Client
-> SwaggerPetstoreRequest TestClientModel contentType Client
testClientModel _ body =
_mkRequest "PATCH" ["/fake"]
`setBodyParam` body
data TestClientModel
instance HasBodyParam TestClientModel Client
instance Consumes TestClientModel MimeJSON
instance Produces TestClientModel MimeJSON
testEndpointParameters
:: (Consumes TestEndpointParameters contentType)
=> contentType
-> Number
-> ParamDouble
-> PatternWithoutDelimiter
-> Byte
-> SwaggerPetstoreRequest TestEndpointParameters contentType res
testEndpointParameters _ (Number number) (ParamDouble double) (PatternWithoutDelimiter patternWithoutDelimiter) (Byte byte) =
_mkRequest "POST" ["/fake"]
`_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHttpBasicTest)
`addForm` toForm ("number", number)
`addForm` toForm ("double", double)
`addForm` toForm ("pattern_without_delimiter", patternWithoutDelimiter)
`addForm` toForm ("byte", byte)
data TestEndpointParameters
instance HasOptionalParam TestEndpointParameters ParamInteger where
applyOptionalParam req (ParamInteger xs) =
req `addForm` toForm ("integer", xs)
instance HasOptionalParam TestEndpointParameters Int32 where
applyOptionalParam req (Int32 xs) =
req `addForm` toForm ("int32", xs)
instance HasOptionalParam TestEndpointParameters Int64 where
applyOptionalParam req (Int64 xs) =
req `addForm` toForm ("int64", xs)
instance HasOptionalParam TestEndpointParameters ParamFloat where
applyOptionalParam req (ParamFloat xs) =
req `addForm` toForm ("float", xs)
instance HasOptionalParam TestEndpointParameters ParamString where
applyOptionalParam req (ParamString xs) =
req `addForm` toForm ("string", xs)
instance HasOptionalParam TestEndpointParameters ParamBinary where
applyOptionalParam req (ParamBinary xs) =
req `addForm` toForm ("binary", xs)
instance HasOptionalParam TestEndpointParameters ParamDate where
applyOptionalParam req (ParamDate xs) =
req `addForm` toForm ("date", xs)
instance HasOptionalParam TestEndpointParameters ParamDateTime where
applyOptionalParam req (ParamDateTime xs) =
req `addForm` toForm ("dateTime", xs)
instance HasOptionalParam TestEndpointParameters Password where
applyOptionalParam req (Password xs) =
req `addForm` toForm ("password", xs)
instance HasOptionalParam TestEndpointParameters Callback where
applyOptionalParam req (Callback xs) =
req `addForm` toForm ("callback", xs)
instance Consumes TestEndpointParameters MimeXmlCharsetutf8
instance Consumes TestEndpointParameters MimeJsonCharsetutf8
instance Produces TestEndpointParameters MimeXmlCharsetutf8
instance Produces TestEndpointParameters MimeJsonCharsetutf8
testEnumParameters
:: (Consumes TestEnumParameters contentType)
=> contentType
-> SwaggerPetstoreRequest TestEnumParameters contentType res
testEnumParameters _ =
_mkRequest "GET" ["/fake"]
data TestEnumParameters
instance HasOptionalParam TestEnumParameters EnumFormStringArray where
applyOptionalParam req (EnumFormStringArray xs) =
req `addForm` toFormColl CommaSeparated ("enum_form_string_array", xs)
instance HasOptionalParam TestEnumParameters EnumFormString where
applyOptionalParam req (EnumFormString xs) =
req `addForm` toForm ("enum_form_string", xs)
instance HasOptionalParam TestEnumParameters EnumHeaderStringArray where
applyOptionalParam req (EnumHeaderStringArray xs) =
req `setHeader` toHeaderColl CommaSeparated ("enum_header_string_array", xs)
instance HasOptionalParam TestEnumParameters EnumHeaderString where
applyOptionalParam req (EnumHeaderString xs) =
req `setHeader` toHeader ("enum_header_string", xs)
instance HasOptionalParam TestEnumParameters EnumQueryStringArray where
applyOptionalParam req (EnumQueryStringArray xs) =
req `setQuery` toQueryColl CommaSeparated ("enum_query_string_array", Just xs)
instance HasOptionalParam TestEnumParameters EnumQueryString where
applyOptionalParam req (EnumQueryString xs) =
req `setQuery` toQuery ("enum_query_string", Just xs)
instance HasOptionalParam TestEnumParameters EnumQueryInteger where
applyOptionalParam req (EnumQueryInteger xs) =
req `setQuery` toQuery ("enum_query_integer", Just xs)
instance HasOptionalParam TestEnumParameters EnumQueryDouble where
applyOptionalParam req (EnumQueryDouble xs) =
req `addForm` toForm ("enum_query_double", xs)
instance Consumes TestEnumParameters MimeAny
instance Produces TestEnumParameters MimeAny
testJsonFormData
:: (Consumes TestJsonFormData contentType)
=> contentType
-> Param
-> Param2
-> SwaggerPetstoreRequest TestJsonFormData contentType NoContent
testJsonFormData _ (Param param) (Param2 param2) =
_mkRequest "GET" ["/fake/jsonFormData"]
`addForm` toForm ("param", param)
`addForm` toForm ("param2", param2)
data TestJsonFormData
instance Consumes TestJsonFormData MimeJSON
testClassname
:: (Consumes TestClassname contentType, MimeRender contentType Client)
=> contentType
-> Client
-> SwaggerPetstoreRequest TestClassname contentType Client
testClassname _ body =
_mkRequest "PATCH" ["/fake_classname_test"]
`_hasAuthType` (P.Proxy :: P.Proxy AuthApiKeyApiKeyQuery)
`setBodyParam` body
data TestClassname
instance HasBodyParam TestClassname Client
instance Consumes TestClassname MimeJSON
instance Produces TestClassname MimeJSON
addPet
:: (Consumes AddPet contentType, MimeRender contentType Pet)
=> contentType
-> Pet
-> SwaggerPetstoreRequest AddPet contentType res
addPet _ body =
_mkRequest "POST" ["/pet"]
`_hasAuthType` (P.Proxy :: P.Proxy AuthOAuthPetstoreAuth)
`setBodyParam` body
data AddPet
instance HasBodyParam AddPet Pet
instance Consumes AddPet MimeJSON
instance Consumes AddPet MimeXML
instance Produces AddPet MimeXML
instance Produces AddPet MimeJSON
deletePet
:: PetId
-> SwaggerPetstoreRequest DeletePet MimeNoContent res
deletePet (PetId petId) =
_mkRequest "DELETE" ["/pet/",toPath petId]
`_hasAuthType` (P.Proxy :: P.Proxy AuthOAuthPetstoreAuth)
data DeletePet
instance HasOptionalParam DeletePet ApiKey where
applyOptionalParam req (ApiKey xs) =
req `setHeader` toHeader ("api_key", xs)
instance Produces DeletePet MimeXML
instance Produces DeletePet MimeJSON
findPetsByStatus
:: Status
-> SwaggerPetstoreRequest FindPetsByStatus MimeNoContent [Pet]
findPetsByStatus (Status status) =
_mkRequest "GET" ["/pet/findByStatus"]
`_hasAuthType` (P.Proxy :: P.Proxy AuthOAuthPetstoreAuth)
`setQuery` toQueryColl CommaSeparated ("status", Just status)
data FindPetsByStatus
instance Produces FindPetsByStatus MimeXML
instance Produces FindPetsByStatus MimeJSON
findPetsByTags
:: Tags
-> SwaggerPetstoreRequest FindPetsByTags MimeNoContent [Pet]
findPetsByTags (Tags tags) =
_mkRequest "GET" ["/pet/findByTags"]
`_hasAuthType` (P.Proxy :: P.Proxy AuthOAuthPetstoreAuth)
`setQuery` toQueryColl CommaSeparated ("tags", Just tags)
data FindPetsByTags
instance Produces FindPetsByTags MimeXML
instance Produces FindPetsByTags MimeJSON
getPetById
:: PetId
-> SwaggerPetstoreRequest GetPetById MimeNoContent Pet
getPetById (PetId petId) =
_mkRequest "GET" ["/pet/",toPath petId]
`_hasAuthType` (P.Proxy :: P.Proxy AuthApiKeyApiKey)
data GetPetById
instance Produces GetPetById MimeXML
instance Produces GetPetById MimeJSON
updatePet
:: (Consumes UpdatePet contentType, MimeRender contentType Pet)
=> contentType
-> Pet
-> SwaggerPetstoreRequest UpdatePet contentType res
updatePet _ body =
_mkRequest "PUT" ["/pet"]
`_hasAuthType` (P.Proxy :: P.Proxy AuthOAuthPetstoreAuth)
`setBodyParam` body
data UpdatePet
instance HasBodyParam UpdatePet Pet
instance Consumes UpdatePet MimeJSON
instance Consumes UpdatePet MimeXML
instance Produces UpdatePet MimeXML
instance Produces UpdatePet MimeJSON
updatePetWithForm
:: (Consumes UpdatePetWithForm contentType)
=> contentType
-> PetId
-> SwaggerPetstoreRequest UpdatePetWithForm contentType res
updatePetWithForm _ (PetId petId) =
_mkRequest "POST" ["/pet/",toPath petId]
`_hasAuthType` (P.Proxy :: P.Proxy AuthOAuthPetstoreAuth)
data UpdatePetWithForm
instance HasOptionalParam UpdatePetWithForm Name2 where
applyOptionalParam req (Name2 xs) =
req `addForm` toForm ("name", xs)
instance HasOptionalParam UpdatePetWithForm StatusText where
applyOptionalParam req (StatusText xs) =
req `addForm` toForm ("status", xs)
instance Consumes UpdatePetWithForm MimeFormUrlEncoded
instance Produces UpdatePetWithForm MimeXML
instance Produces UpdatePetWithForm MimeJSON
uploadFile
:: (Consumes UploadFile contentType)
=> contentType
-> PetId
-> SwaggerPetstoreRequest UploadFile contentType ApiResponse
uploadFile _ (PetId petId) =
_mkRequest "POST" ["/pet/",toPath petId,"/uploadImage"]
`_hasAuthType` (P.Proxy :: P.Proxy AuthOAuthPetstoreAuth)
data UploadFile
instance HasOptionalParam UploadFile AdditionalMetadata where
applyOptionalParam req (AdditionalMetadata xs) =
req `_addMultiFormPart` NH.partLBS "additionalMetadata" (mimeRender' MimeMultipartFormData xs)
instance HasOptionalParam UploadFile File where
applyOptionalParam req (File xs) =
req `_addMultiFormPart` NH.partFileSource "file" xs
instance Consumes UploadFile MimeMultipartFormData
instance Produces UploadFile MimeJSON
deleteOrder
:: OrderIdText
-> SwaggerPetstoreRequest DeleteOrder MimeNoContent res
deleteOrder (OrderIdText orderId) =
_mkRequest "DELETE" ["/store/order/",toPath orderId]
data DeleteOrder
instance Produces DeleteOrder MimeXML
instance Produces DeleteOrder MimeJSON
getInventory
:: SwaggerPetstoreRequest GetInventory MimeNoContent ((Map.Map String Int))
getInventory =
_mkRequest "GET" ["/store/inventory"]
`_hasAuthType` (P.Proxy :: P.Proxy AuthApiKeyApiKey)
data GetInventory
instance Produces GetInventory MimeJSON
getOrderById
:: OrderId
-> SwaggerPetstoreRequest GetOrderById MimeNoContent Order
getOrderById (OrderId orderId) =
_mkRequest "GET" ["/store/order/",toPath orderId]
data GetOrderById
instance Produces GetOrderById MimeXML
instance Produces GetOrderById MimeJSON
placeOrder
:: (Consumes PlaceOrder contentType, MimeRender contentType Order)
=> contentType
-> Order
-> SwaggerPetstoreRequest PlaceOrder contentType Order
placeOrder _ body =
_mkRequest "POST" ["/store/order"]
`setBodyParam` body
data PlaceOrder
instance HasBodyParam PlaceOrder Order
instance Produces PlaceOrder MimeXML
instance Produces PlaceOrder MimeJSON
createUser
:: (Consumes CreateUser contentType, MimeRender contentType User)
=> contentType
-> User
-> SwaggerPetstoreRequest CreateUser contentType res
createUser _ body =
_mkRequest "POST" ["/user"]
`setBodyParam` body
data CreateUser
instance HasBodyParam CreateUser User
instance Produces CreateUser MimeXML
instance Produces CreateUser MimeJSON
createUsersWithArrayInput
:: (Consumes CreateUsersWithArrayInput contentType, MimeRender contentType Body)
=> contentType
-> Body
-> SwaggerPetstoreRequest CreateUsersWithArrayInput contentType res
createUsersWithArrayInput _ body =
_mkRequest "POST" ["/user/createWithArray"]
`setBodyParam` body
data CreateUsersWithArrayInput
instance HasBodyParam CreateUsersWithArrayInput Body
instance Produces CreateUsersWithArrayInput MimeXML
instance Produces CreateUsersWithArrayInput MimeJSON
createUsersWithListInput
:: (Consumes CreateUsersWithListInput contentType, MimeRender contentType Body)
=> contentType
-> Body
-> SwaggerPetstoreRequest CreateUsersWithListInput contentType res
createUsersWithListInput _ body =
_mkRequest "POST" ["/user/createWithList"]
`setBodyParam` body
data CreateUsersWithListInput
instance HasBodyParam CreateUsersWithListInput Body
instance Produces CreateUsersWithListInput MimeXML
instance Produces CreateUsersWithListInput MimeJSON
deleteUser
:: Username
-> SwaggerPetstoreRequest DeleteUser MimeNoContent res
deleteUser (Username username) =
_mkRequest "DELETE" ["/user/",toPath username]
data DeleteUser
instance Produces DeleteUser MimeXML
instance Produces DeleteUser MimeJSON
getUserByName
:: Username
-> SwaggerPetstoreRequest GetUserByName MimeNoContent User
getUserByName (Username username) =
_mkRequest "GET" ["/user/",toPath username]
data GetUserByName
instance Produces GetUserByName MimeXML
instance Produces GetUserByName MimeJSON
loginUser
:: Username
-> Password
-> SwaggerPetstoreRequest LoginUser MimeNoContent Text
loginUser (Username username) (Password password) =
_mkRequest "GET" ["/user/login"]
`setQuery` toQuery ("username", Just username)
`setQuery` toQuery ("password", Just password)
data LoginUser
instance Produces LoginUser MimeXML
instance Produces LoginUser MimeJSON
logoutUser
:: SwaggerPetstoreRequest LogoutUser MimeNoContent res
logoutUser =
_mkRequest "GET" ["/user/logout"]
data LogoutUser
instance Produces LogoutUser MimeXML
instance Produces LogoutUser MimeJSON
updateUser
:: (Consumes UpdateUser contentType, MimeRender contentType User)
=> contentType
-> Username
-> User
-> SwaggerPetstoreRequest UpdateUser contentType res
updateUser _ (Username username) body =
_mkRequest "PUT" ["/user/",toPath username]
`setBodyParam` body
data UpdateUser
instance HasBodyParam UpdateUser User
instance Produces UpdateUser MimeXML
instance Produces UpdateUser MimeJSON
newtype AdditionalMetadata = AdditionalMetadata { unAdditionalMetadata :: Text } deriving (P.Eq, P.Show)
newtype ApiKey = ApiKey { unApiKey :: Text } deriving (P.Eq, P.Show)
newtype Body = Body { unBody :: [User] } deriving (P.Eq, P.Show, A.ToJSON)
newtype Byte = Byte { unByte :: ByteArray } deriving (P.Eq, P.Show)
newtype Callback = Callback { unCallback :: Text } deriving (P.Eq, P.Show)
newtype EnumFormString = EnumFormString { unEnumFormString :: Text } deriving (P.Eq, P.Show)
newtype EnumFormStringArray = EnumFormStringArray { unEnumFormStringArray :: [Text] } deriving (P.Eq, P.Show)
newtype EnumHeaderString = EnumHeaderString { unEnumHeaderString :: Text } deriving (P.Eq, P.Show)
newtype EnumHeaderStringArray = EnumHeaderStringArray { unEnumHeaderStringArray :: [Text] } deriving (P.Eq, P.Show)
newtype EnumQueryDouble = EnumQueryDouble { unEnumQueryDouble :: Double } deriving (P.Eq, P.Show)
newtype EnumQueryInteger = EnumQueryInteger { unEnumQueryInteger :: Int } deriving (P.Eq, P.Show)
newtype EnumQueryString = EnumQueryString { unEnumQueryString :: Text } deriving (P.Eq, P.Show)
newtype EnumQueryStringArray = EnumQueryStringArray { unEnumQueryStringArray :: [Text] } deriving (P.Eq, P.Show)
newtype File = File { unFile :: FilePath } deriving (P.Eq, P.Show)
newtype Int32 = Int32 { unInt32 :: Int } deriving (P.Eq, P.Show)
newtype Int64 = Int64 { unInt64 :: Integer } deriving (P.Eq, P.Show)
newtype Name2 = Name2 { unName2 :: Text } deriving (P.Eq, P.Show)
newtype Number = Number { unNumber :: Double } deriving (P.Eq, P.Show)
newtype OrderId = OrderId { unOrderId :: Integer } deriving (P.Eq, P.Show)
newtype OrderIdText = OrderIdText { unOrderIdText :: Text } deriving (P.Eq, P.Show)
newtype Param = Param { unParam :: Text } deriving (P.Eq, P.Show)
newtype Param2 = Param2 { unParam2 :: Text } deriving (P.Eq, P.Show)
newtype ParamBinary = ParamBinary { unParamBinary :: Binary } deriving (P.Eq, P.Show)
newtype ParamDate = ParamDate { unParamDate :: Date } deriving (P.Eq, P.Show)
newtype ParamDateTime = ParamDateTime { unParamDateTime :: DateTime } deriving (P.Eq, P.Show)
newtype ParamDouble = ParamDouble { unParamDouble :: Double } deriving (P.Eq, P.Show)
newtype ParamFloat = ParamFloat { unParamFloat :: Float } deriving (P.Eq, P.Show)
newtype ParamInteger = ParamInteger { unParamInteger :: Int } deriving (P.Eq, P.Show)
newtype ParamString = ParamString { unParamString :: Text } deriving (P.Eq, P.Show)
newtype Password = Password { unPassword :: Text } deriving (P.Eq, P.Show)
newtype PatternWithoutDelimiter = PatternWithoutDelimiter { unPatternWithoutDelimiter :: Text } deriving (P.Eq, P.Show)
newtype PetId = PetId { unPetId :: Integer } deriving (P.Eq, P.Show)
newtype Status = Status { unStatus :: [Text] } deriving (P.Eq, P.Show)
newtype StatusText = StatusText { unStatusText :: Text } deriving (P.Eq, P.Show)
newtype Tags = Tags { unTags :: [Text] } deriving (P.Eq, P.Show)
newtype Username = Username { unUsername :: Text } deriving (P.Eq, P.Show)
data AuthApiKeyApiKey =
AuthApiKeyApiKey Text
deriving (P.Eq, P.Show, P.Typeable)
instance AuthMethod AuthApiKeyApiKey where
applyAuthMethod _ a@(AuthApiKeyApiKey secret) req =
P.pure $
if (P.typeOf a `P.elem` rAuthTypes req)
then req `setHeader` toHeader ("api_key", secret)
& L.over rAuthTypesL (P.filter (/= P.typeOf a))
else req
data AuthApiKeyApiKeyQuery =
AuthApiKeyApiKeyQuery Text
deriving (P.Eq, P.Show, P.Typeable)
instance AuthMethod AuthApiKeyApiKeyQuery where
applyAuthMethod _ a@(AuthApiKeyApiKeyQuery secret) req =
P.pure $
if (P.typeOf a `P.elem` rAuthTypes req)
then req `setQuery` toQuery ("api_key_query", Just secret)
& L.over rAuthTypesL (P.filter (/= P.typeOf a))
else req
data AuthBasicHttpBasicTest =
AuthBasicHttpBasicTest B.ByteString B.ByteString
deriving (P.Eq, P.Show, P.Typeable)
instance AuthMethod AuthBasicHttpBasicTest where
applyAuthMethod _ a@(AuthBasicHttpBasicTest user pw) req =
P.pure $
if (P.typeOf a `P.elem` rAuthTypes req)
then req `setHeader` toHeader ("Authorization", T.decodeUtf8 cred)
& L.over rAuthTypesL (P.filter (/= P.typeOf a))
else req
where cred = BC.append "Basic " (B64.encode $ BC.concat [ user, ":", pw ])
data AuthOAuthPetstoreAuth =
AuthOAuthPetstoreAuth Text
deriving (P.Eq, P.Show, P.Typeable)
instance AuthMethod AuthOAuthPetstoreAuth where
applyAuthMethod _ a@(AuthOAuthPetstoreAuth secret) req =
P.pure $
if (P.typeOf a `P.elem` rAuthTypes req)
then req `setHeader` toHeader ("Authorization", "Bearer " <> secret)
& L.over rAuthTypesL (P.filter (/= P.typeOf a))
else req
data MimeJsonCharsetutf8 = MimeJsonCharsetutf8 deriving (P.Typeable)
instance MimeType MimeJsonCharsetutf8 where
mimeType _ = Just $ P.fromString "application/json; charset=utf-8"
instance A.ToJSON a => MimeRender MimeJsonCharsetutf8 a where mimeRender _ = A.encode
instance A.FromJSON a => MimeUnrender MimeJsonCharsetutf8 a where mimeUnrender _ = A.eitherDecode
data MimeXmlCharsetutf8 = MimeXmlCharsetutf8 deriving (P.Typeable)
instance MimeType MimeXmlCharsetutf8 where
mimeType _ = Just $ P.fromString "application/xml; charset=utf-8"