{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MonoLocalBinds #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-binds -fno-warn-unused-imports #-}
module OpenAPIPetstore.API.Fake where
import OpenAPIPetstore.Core
import OpenAPIPetstore.MimeTypes
import OpenAPIPetstore.Model as M
import qualified Data.Aeson as A
import qualified Data.ByteString as B
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 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.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
fakeOuterBooleanSerialize
:: (Consumes FakeOuterBooleanSerialize MimeJSON)
=> Accept accept
-> OpenAPIPetstoreRequest FakeOuterBooleanSerialize MimeJSON Bool accept
fakeOuterBooleanSerialize _ =
_mkRequest "POST" ["/fake/outer/boolean"]
data FakeOuterBooleanSerialize
instance HasBodyParam FakeOuterBooleanSerialize BodyBool
instance Consumes FakeOuterBooleanSerialize MimeJSON
instance MimeType mtype => Produces FakeOuterBooleanSerialize mtype
fakeOuterCompositeSerialize
:: (Consumes FakeOuterCompositeSerialize MimeJSON)
=> Accept accept
-> OpenAPIPetstoreRequest FakeOuterCompositeSerialize MimeJSON OuterComposite accept
fakeOuterCompositeSerialize _ =
_mkRequest "POST" ["/fake/outer/composite"]
data FakeOuterCompositeSerialize
instance HasBodyParam FakeOuterCompositeSerialize OuterComposite
instance Consumes FakeOuterCompositeSerialize MimeJSON
instance MimeType mtype => Produces FakeOuterCompositeSerialize mtype
fakeOuterNumberSerialize
:: (Consumes FakeOuterNumberSerialize MimeJSON)
=> Accept accept
-> OpenAPIPetstoreRequest FakeOuterNumberSerialize MimeJSON Double accept
fakeOuterNumberSerialize _ =
_mkRequest "POST" ["/fake/outer/number"]
data FakeOuterNumberSerialize
instance HasBodyParam FakeOuterNumberSerialize Body
instance Consumes FakeOuterNumberSerialize MimeJSON
instance MimeType mtype => Produces FakeOuterNumberSerialize mtype
fakeOuterStringSerialize
:: (Consumes FakeOuterStringSerialize MimeJSON)
=> Accept accept
-> OpenAPIPetstoreRequest FakeOuterStringSerialize MimeJSON Text accept
fakeOuterStringSerialize _ =
_mkRequest "POST" ["/fake/outer/string"]
data FakeOuterStringSerialize
instance HasBodyParam FakeOuterStringSerialize BodyText
instance Consumes FakeOuterStringSerialize MimeJSON
instance MimeType mtype => Produces FakeOuterStringSerialize mtype
testClientModel
:: (Consumes TestClientModel MimeJSON, MimeRender MimeJSON Client)
=> Client
-> OpenAPIPetstoreRequest TestClientModel MimeJSON Client MimeJSON
testClientModel client =
_mkRequest "PATCH" ["/fake"]
`setBodyParam` client
data TestClientModel
instance HasBodyParam TestClientModel Client
instance Consumes TestClientModel MimeJSON
instance Produces TestClientModel MimeJSON
testEndpointParameters
:: (Consumes TestEndpointParameters MimeFormUrlEncoded)
=> Number
-> ParamDouble
-> PatternWithoutDelimiter
-> Byte
-> OpenAPIPetstoreRequest TestEndpointParameters MimeFormUrlEncoded NoContent MimeNoContent
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 `_addMultiFormPart` NH.partFileSource "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 MimeFormUrlEncoded
instance Produces TestEndpointParameters MimeNoContent
testEnumParameters
:: (Consumes TestEnumParameters MimeFormUrlEncoded)
=> OpenAPIPetstoreRequest TestEnumParameters MimeFormUrlEncoded NoContent MimeNoContent
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 MultiParamArray ("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 `setQuery` toQuery ("enum_query_double", Just xs)
instance Consumes TestEnumParameters MimeFormUrlEncoded
instance Produces TestEnumParameters MimeNoContent
testInlineAdditionalProperties
:: (Consumes TestInlineAdditionalProperties MimeJSON, MimeRender MimeJSON RequestBody)
=> RequestBody
-> OpenAPIPetstoreRequest TestInlineAdditionalProperties MimeJSON NoContent MimeNoContent
testInlineAdditionalProperties requestBody =
_mkRequest "POST" ["/fake/inline-additionalProperties"]
`setBodyParam` requestBody
data TestInlineAdditionalProperties
instance HasBodyParam TestInlineAdditionalProperties RequestBody
instance Consumes TestInlineAdditionalProperties MimeJSON
instance Produces TestInlineAdditionalProperties MimeNoContent
testJsonFormData
:: (Consumes TestJsonFormData MimeFormUrlEncoded)
=> Param
-> Param2
-> OpenAPIPetstoreRequest TestJsonFormData MimeFormUrlEncoded NoContent MimeNoContent
testJsonFormData (Param param) (Param2 param2) =
_mkRequest "GET" ["/fake/jsonFormData"]
`addForm` toForm ("param", param)
`addForm` toForm ("param2", param2)
data TestJsonFormData
instance Consumes TestJsonFormData MimeFormUrlEncoded
instance Produces TestJsonFormData MimeNoContent