module SwaggerPetstore.API.Fake 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.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 contentType)
=> ContentType contentType
-> Accept accept
-> SwaggerPetstoreRequest FakeOuterBooleanSerialize contentType OuterBoolean accept
fakeOuterBooleanSerialize _ _ =
_mkRequest "POST" ["/fake/outer/boolean"]
data FakeOuterBooleanSerialize
instance HasBodyParam FakeOuterBooleanSerialize OuterBoolean
fakeOuterCompositeSerialize
:: (Consumes FakeOuterCompositeSerialize contentType)
=> ContentType contentType
-> Accept accept
-> SwaggerPetstoreRequest FakeOuterCompositeSerialize contentType OuterComposite accept
fakeOuterCompositeSerialize _ _ =
_mkRequest "POST" ["/fake/outer/composite"]
data FakeOuterCompositeSerialize
instance HasBodyParam FakeOuterCompositeSerialize OuterComposite
fakeOuterNumberSerialize
:: (Consumes FakeOuterNumberSerialize contentType)
=> ContentType contentType
-> Accept accept
-> SwaggerPetstoreRequest FakeOuterNumberSerialize contentType OuterNumber accept
fakeOuterNumberSerialize _ _ =
_mkRequest "POST" ["/fake/outer/number"]
data FakeOuterNumberSerialize
instance HasBodyParam FakeOuterNumberSerialize OuterNumber
fakeOuterStringSerialize
:: (Consumes FakeOuterStringSerialize contentType)
=> ContentType contentType
-> Accept accept
-> SwaggerPetstoreRequest FakeOuterStringSerialize contentType OuterString accept
fakeOuterStringSerialize _ _ =
_mkRequest "POST" ["/fake/outer/string"]
data FakeOuterStringSerialize
instance HasBodyParam FakeOuterStringSerialize OuterString
testClientModel
:: (Consumes TestClientModel MimeJSON, MimeRender MimeJSON Client)
=> Client
-> SwaggerPetstoreRequest TestClientModel MimeJSON Client MimeJSON
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 contentType
-> Accept accept
-> Number
-> ParamDouble
-> PatternWithoutDelimiter
-> Byte
-> SwaggerPetstoreRequest TestEndpointParameters contentType res accept
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 contentType
-> Accept accept
-> SwaggerPetstoreRequest TestEnumParameters contentType res accept
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 MimeType mtype => Consumes TestEnumParameters mtype
instance MimeType mtype => Produces TestEnumParameters mtype
testInlineAdditionalProperties
:: (Consumes TestInlineAdditionalProperties MimeJSON, MimeRender MimeJSON A.Value)
=> A.Value
-> SwaggerPetstoreRequest TestInlineAdditionalProperties MimeJSON NoContent MimeNoContent
testInlineAdditionalProperties param =
_mkRequest "POST" ["/fake/inline-additionalProperties"]
`setBodyParam` param
data TestInlineAdditionalProperties
instance HasBodyParam TestInlineAdditionalProperties A.Value
instance Consumes TestInlineAdditionalProperties MimeJSON
testJsonFormData
:: (Consumes TestJsonFormData MimeJSON)
=> Param
-> Param2
-> SwaggerPetstoreRequest TestJsonFormData MimeJSON NoContent MimeNoContent
testJsonFormData (Param param) (Param2 param2) =
_mkRequest "GET" ["/fake/jsonFormData"]
`addForm` toForm ("param", param)
`addForm` toForm ("param2", param2)
data TestJsonFormData
instance Consumes TestJsonFormData MimeJSON