swagger-petstore 0.0.1.1 → 0.0.1.2

raw patch · 13 files changed

+3637/−577 lines, 13 filesdep +base64-bytestringdep +deepseqdep +katipdep −monad-loggerPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: base64-bytestring, deepseq, katip

Dependencies removed: monad-logger

API changes (from Hackage documentation)

Files

• LICENSE +0/−21
• README.md +2/−0
• lib/SwaggerPetstore.hs +2/−0
• lib/SwaggerPetstore/API.hs +400/−13
• lib/SwaggerPetstore/Client.hs +39/−92
• lib/SwaggerPetstore/Lens.hs +445/−8
• lib/SwaggerPetstore/Logging.hs +108/−0
• lib/SwaggerPetstore/MimeTypes.hs +50/−21
• lib/SwaggerPetstore/Model.hs +1397/−358
• swagger-petstore.cabal +13/−9
• swagger.json +881/−19
• tests/Instances.hs +269/−35
• tests/Test.hs +31/−1

@@ -1,21 +0,0 @@-The MIT License (MIT)--Copyright (c) 2015 Jon Schoning--Permission is hereby granted, free of charge, to any person obtaining a copy-of this software and associated documentation files (the "Software"), to deal-in the Software without restriction, including without limitation the rights-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell-copies of the Software, and to permit persons to whom the Software is-furnished to do so, subject to the following conditions:--The above copyright notice and this permission notice shall be included in-all copies or substantial portions of the Software.--THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN-THE SOFTWARE.

@@ -76,6 +76,7 @@ | generateModelConstructors       | Generate smart constructors (only supply required fields) for models                                                          | true     | true       | | modelDeriving                   | Additional classes to include in the deriving() clause of Models                                                              |          |                    | | strictFields                    | Add strictness annotations to all model fields                                                                                | true     | true                  |+| useMonadLogger                  | Use the monad-logger package to provide logging (if instead false, use the katip logging package)                             | false    | false                |  [1]: https://www.stackage.org/haddock/lts-9.0/iso8601-time-0.1.4/Data-Time-ISO8601.html#v:formatISO8601Millis @@ -115,6 +116,7 @@ | SwaggerPetstore.Model     | describes models                                    | | SwaggerPetstore.MimeTypes | encoding/decoding MIME types (content-types/accept) | | SwaggerPetstore.Lens      | lenses for model fields                             |+| SwaggerPetstore.Logging   | logging functions and utils                         |  This library adds type safety around what swagger specifies as Produces and Consumes for each Operation (e.g. the list of MIME types an

@@ -8,6 +8,7 @@   , module SwaggerPetstore.Model   , module SwaggerPetstore.MimeTypes   , module SwaggerPetstore.Lens+  , module SwaggerPetstore.Logging   ) where  import SwaggerPetstore.API@@ -15,3 +16,4 @@ import SwaggerPetstore.Model import SwaggerPetstore.MimeTypes import SwaggerPetstore.Lens+import SwaggerPetstore.Logging

@@ -22,14 +22,11 @@ import SwaggerPetstore.Lens  import qualified Data.Aeson as A-import Data.Aeson (Value)  import qualified Data.Time as TI-import Data.Time (UTCTime)  import qualified Data.ByteString as B import qualified Data.ByteString.Lazy as BL-import Data.ByteString.Lazy (ByteString) import qualified Data.ByteString.Builder as BB import qualified Data.ByteString.Char8 as BC import qualified Data.ByteString.Lazy.Char8 as BCL@@ -45,6 +42,7 @@ import qualified Data.Data as P (Typeable) import qualified Data.Foldable as P import qualified Data.Map as Map+import qualified Data.Set as Set import qualified Data.Maybe as P import qualified Data.Proxy as P (Proxy(..)) import qualified Data.Text as T@@ -58,7 +56,6 @@  import Data.Monoid ((<>)) import Data.Function ((&))-import Data.Set (Set) import Data.Text (Text) import GHC.Base ((<|>)) @@ -68,6 +65,352 @@ -- * Operations  +-- ** AnotherFake++-- *** testSpecialTags++-- | @PATCH \/another-fake\/dummy@+-- +-- To test special tags+-- +-- To test special tags+-- +testSpecialTags +  :: (Consumes TestSpecialTags contentType, MimeRender contentType Client)+  => contentType -- ^ request content-type ('MimeType')+  -> Client -- ^ "body" -  client model+  -> SwaggerPetstoreRequest TestSpecialTags contentType Client+testSpecialTags _ body =+  _mkRequest "PATCH" ["/another-fake/dummy"]+    `setBodyParam` body++data TestSpecialTags ++-- | /Body Param/ "body" - client model+instance HasBodyParam TestSpecialTags Client ++-- | @application/json@+instance Consumes TestSpecialTags MimeJSON++-- | @application/json@+instance Produces TestSpecialTags MimeJSON+++-- ** Fake++-- *** fakeOuterBooleanSerialize++-- | @POST \/fake\/outer\/boolean@+-- +-- Test serialization of outer boolean types+-- +fakeOuterBooleanSerialize +  :: (Consumes FakeOuterBooleanSerialize contentType)+  => contentType -- ^ request content-type ('MimeType')+  -> SwaggerPetstoreRequest FakeOuterBooleanSerialize contentType OuterBoolean+fakeOuterBooleanSerialize _ =+  _mkRequest "POST" ["/fake/outer/boolean"]++data FakeOuterBooleanSerialize ++-- | /Body Param/ "body" - Input boolean as post body+instance HasBodyParam FakeOuterBooleanSerialize OuterBoolean ++-- *** fakeOuterCompositeSerialize++-- | @POST \/fake\/outer\/composite@+-- +-- Test serialization of object with outer number type+-- +fakeOuterCompositeSerialize +  :: (Consumes FakeOuterCompositeSerialize contentType)+  => contentType -- ^ request content-type ('MimeType')+  -> SwaggerPetstoreRequest FakeOuterCompositeSerialize contentType OuterComposite+fakeOuterCompositeSerialize _ =+  _mkRequest "POST" ["/fake/outer/composite"]++data FakeOuterCompositeSerialize ++-- | /Body Param/ "body" - Input composite as post body+instance HasBodyParam FakeOuterCompositeSerialize OuterComposite ++-- *** fakeOuterNumberSerialize++-- | @POST \/fake\/outer\/number@+-- +-- Test serialization of outer number types+-- +fakeOuterNumberSerialize +  :: (Consumes FakeOuterNumberSerialize contentType)+  => contentType -- ^ request content-type ('MimeType')+  -> SwaggerPetstoreRequest FakeOuterNumberSerialize contentType OuterNumber+fakeOuterNumberSerialize _ =+  _mkRequest "POST" ["/fake/outer/number"]++data FakeOuterNumberSerialize ++-- | /Body Param/ "body" - Input number as post body+instance HasBodyParam FakeOuterNumberSerialize OuterNumber ++-- *** fakeOuterStringSerialize++-- | @POST \/fake\/outer\/string@+-- +-- Test serialization of outer string types+-- +fakeOuterStringSerialize +  :: (Consumes FakeOuterStringSerialize contentType)+  => contentType -- ^ request content-type ('MimeType')+  -> SwaggerPetstoreRequest FakeOuterStringSerialize contentType OuterString+fakeOuterStringSerialize _ =+  _mkRequest "POST" ["/fake/outer/string"]++data FakeOuterStringSerialize ++-- | /Body Param/ "body" - Input string as post body+instance HasBodyParam FakeOuterStringSerialize OuterString ++-- *** testClientModel++-- | @PATCH \/fake@+-- +-- To test \"client\" model+-- +-- To test \"client\" model+-- +testClientModel +  :: (Consumes TestClientModel contentType, MimeRender contentType Client)+  => contentType -- ^ request content-type ('MimeType')+  -> Client -- ^ "body" -  client model+  -> SwaggerPetstoreRequest TestClientModel contentType Client+testClientModel _ body =+  _mkRequest "PATCH" ["/fake"]+    `setBodyParam` body++data TestClientModel ++-- | /Body Param/ "body" - client model+instance HasBodyParam TestClientModel Client ++-- | @application/json@+instance Consumes TestClientModel MimeJSON++-- | @application/json@+instance Produces TestClientModel MimeJSON+++-- *** testEndpointParameters++-- | @POST \/fake@+-- +-- Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 +-- +-- Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 +-- +-- AuthMethod: http_basic_test+-- +-- Note: Has 'Produces' instances, but no response schema+-- +testEndpointParameters +  :: (Consumes TestEndpointParameters contentType)+  => contentType -- ^ request content-type ('MimeType')+  -> Double -- ^ "number" -  None+  -> Double -- ^ "double" -  None+  -> Text -- ^ "patternWithoutDelimiter" -  None+  -> ByteArray -- ^ "byte" -  None+  -> SwaggerPetstoreRequest TestEndpointParameters contentType res+testEndpointParameters _ number double patternWithoutDelimiter byte =+  _mkRequest "POST" ["/fake"]+    `_addForm` toForm ("number", number)+    `_addForm` toForm ("double", double)+    `_addForm` toForm ("pattern_without_delimiter", patternWithoutDelimiter)+    `_addForm` toForm ("byte", byte)++data TestEndpointParameters  ++-- | /Optional Param/ "integer" - None+instance HasOptionalParam TestEndpointParameters ParamInteger where+  applyOptionalParam req (ParamInteger xs) =+    req `_addForm` toForm ("integer", xs)++-- | /Optional Param/ "int32" - None+instance HasOptionalParam TestEndpointParameters Int32 where+  applyOptionalParam req (Int32 xs) =+    req `_addForm` toForm ("int32", xs)++-- | /Optional Param/ "int64" - None+instance HasOptionalParam TestEndpointParameters Int64 where+  applyOptionalParam req (Int64 xs) =+    req `_addForm` toForm ("int64", xs)++-- | /Optional Param/ "float" - None+instance HasOptionalParam TestEndpointParameters ParamFloat where+  applyOptionalParam req (ParamFloat xs) =+    req `_addForm` toForm ("float", xs)++-- | /Optional Param/ "string" - None+instance HasOptionalParam TestEndpointParameters ParamString where+  applyOptionalParam req (ParamString xs) =+    req `_addForm` toForm ("string", xs)++-- | /Optional Param/ "binary" - None+instance HasOptionalParam TestEndpointParameters ParamBinary where+  applyOptionalParam req (ParamBinary xs) =+    req `_addForm` toForm ("binary", xs)++-- | /Optional Param/ "date" - None+instance HasOptionalParam TestEndpointParameters ParamDate where+  applyOptionalParam req (ParamDate xs) =+    req `_addForm` toForm ("date", xs)++-- | /Optional Param/ "dateTime" - None+instance HasOptionalParam TestEndpointParameters ParamDateTime where+  applyOptionalParam req (ParamDateTime xs) =+    req `_addForm` toForm ("dateTime", xs)++-- | /Optional Param/ "password" - None+instance HasOptionalParam TestEndpointParameters Password where+  applyOptionalParam req (Password xs) =+    req `_addForm` toForm ("password", xs)++-- | /Optional Param/ "callback" - None+instance HasOptionalParam TestEndpointParameters Callback where+  applyOptionalParam req (Callback xs) =+    req `_addForm` toForm ("callback", xs)++-- | @application/xml; charset=utf-8@+instance Consumes TestEndpointParameters MimeXmlCharsetutf8+-- | @application/json; charset=utf-8@+instance Consumes TestEndpointParameters MimeJsonCharsetutf8++-- | @application/xml; charset=utf-8@+instance Produces TestEndpointParameters MimeXmlCharsetutf8+-- | @application/json; charset=utf-8@+instance Produces TestEndpointParameters MimeJsonCharsetutf8+++-- *** testEnumParameters++-- | @GET \/fake@+-- +-- To test enum parameters+-- +-- To test enum parameters+-- +-- Note: Has 'Produces' instances, but no response schema+-- +testEnumParameters +  :: (Consumes TestEnumParameters contentType)+  => contentType -- ^ request content-type ('MimeType')+  -> SwaggerPetstoreRequest TestEnumParameters contentType res+testEnumParameters _ =+  _mkRequest "GET" ["/fake"]++data TestEnumParameters  ++-- | /Optional Param/ "enum_form_string_array" - Form parameter enum test (string array)+instance HasOptionalParam TestEnumParameters EnumFormStringArray where+  applyOptionalParam req (EnumFormStringArray xs) =+    req `_addForm` toFormColl CommaSeparated ("enum_form_string_array", xs)++-- | /Optional Param/ "enum_form_string" - Form parameter enum test (string)+instance HasOptionalParam TestEnumParameters EnumFormString where+  applyOptionalParam req (EnumFormString xs) =+    req `_addForm` toForm ("enum_form_string", xs)++-- | /Optional Param/ "enum_header_string_array" - Header parameter enum test (string array)+instance HasOptionalParam TestEnumParameters EnumHeaderStringArray where+  applyOptionalParam req (EnumHeaderStringArray xs) =+    req `setHeader` toHeaderColl CommaSeparated ("enum_header_string_array", xs)++-- | /Optional Param/ "enum_header_string" - Header parameter enum test (string)+instance HasOptionalParam TestEnumParameters EnumHeaderString where+  applyOptionalParam req (EnumHeaderString xs) =+    req `setHeader` toHeader ("enum_header_string", xs)++-- | /Optional Param/ "enum_query_string_array" - Query parameter enum test (string array)+instance HasOptionalParam TestEnumParameters EnumQueryStringArray where+  applyOptionalParam req (EnumQueryStringArray xs) =+    req `_setQuery` toQueryColl CommaSeparated ("enum_query_string_array", Just xs)++-- | /Optional Param/ "enum_query_string" - Query parameter enum test (string)+instance HasOptionalParam TestEnumParameters EnumQueryString where+  applyOptionalParam req (EnumQueryString xs) =+    req `_setQuery` toQuery ("enum_query_string", Just xs)++-- | /Optional Param/ "enum_query_integer" - Query parameter enum test (double)+instance HasOptionalParam TestEnumParameters EnumQueryInteger where+  applyOptionalParam req (EnumQueryInteger xs) =+    req `_setQuery` toQuery ("enum_query_integer", Just xs)++-- | /Optional Param/ "enum_query_double" - Query parameter enum test (double)+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++-- | @GET \/fake\/jsonFormData@+-- +-- test json serialization of form data+-- +-- +-- +testJsonFormData +  :: (Consumes TestJsonFormData contentType)+  => contentType -- ^ request content-type ('MimeType')+  -> Text -- ^ "param" -  field1+  -> Text -- ^ "param2" -  field2+  -> SwaggerPetstoreRequest TestJsonFormData contentType NoContent+testJsonFormData _ param param2 =+  _mkRequest "GET" ["/fake/jsonFormData"]+    `_addForm` toForm ("param", param)+    `_addForm` toForm ("param2", param2)++data TestJsonFormData  ++-- | @application/json@+instance Consumes TestJsonFormData MimeJSON+++-- ** FakeClassnameTags123++-- *** testClassname++-- | @PATCH \/fake_classname_test@+-- +-- To test class name in snake case+-- +-- AuthMethod: api_key_query+-- +testClassname +  :: (Consumes TestClassname contentType, MimeRender contentType Client)+  => contentType -- ^ request content-type ('MimeType')+  -> Client -- ^ "body" -  client model+  -> SwaggerPetstoreRequest TestClassname contentType Client+testClassname _ body =+  _mkRequest "PATCH" ["/fake_classname_test"]+    `setBodyParam` body++data TestClassname ++-- | /Body Param/ "body" - client model+instance HasBodyParam TestClassname Client ++-- | @application/json@+instance Consumes TestClassname MimeJSON++-- | @application/json@+instance Produces TestClassname MimeJSON++ -- ** Pet  -- *** addPet@@ -127,8 +470,8 @@       data DeletePet  -instance HasOptionalParam DeletePet ApiUnderscorekey where-  applyOptionalParam req (ApiUnderscorekey xs) =+instance HasOptionalParam DeletePet ApiKey where+  applyOptionalParam req (ApiKey xs) =     req `setHeader` toHeader ("api_key", xs) -- | @application/xml@ instance Produces DeletePet MimeXML@@ -271,8 +614,8 @@ data UpdatePetWithForm    -- | /Optional Param/ "name" - Updated name of the pet-instance HasOptionalParam UpdatePetWithForm Name where-  applyOptionalParam req (Name xs) =+instance HasOptionalParam UpdatePetWithForm Name2 where+  applyOptionalParam req (Name2 xs) =     req `_addForm` toForm ("name", xs)  -- | /Optional Param/ "status" - Updated status of the pet@@ -331,7 +674,7 @@  -- *** deleteOrder --- | @DELETE \/store\/order\/{orderId}@+-- | @DELETE \/store\/order\/{order_id}@ --  -- Delete purchase order by ID -- @@ -364,7 +707,7 @@ -- AuthMethod: api_key --  getInventory -  :: SwaggerPetstoreRequest GetInventory MimeNoContent (Map.Map String Int)+  :: SwaggerPetstoreRequest GetInventory MimeNoContent ((Map.Map String Int)) getInventory =   _mkRequest "GET" ["/store/inventory"] @@ -375,7 +718,7 @@  -- *** getOrderById --- | @GET \/store\/order\/{orderId}@+-- | @GET \/store\/order\/{order_id}@ --  -- Find purchase order by ID -- @@ -664,9 +1007,53 @@ -- * Optional Request Parameter Types  -newtype ApiUnderscorekey = ApiUnderscorekey { unApiUnderscorekey :: Text } deriving (P.Eq, P.Show)+newtype BodyOuterBoolean = BodyOuterBoolean { unBodyOuterBoolean :: OuterBoolean } deriving (P.Eq, P.Show) -newtype Name = Name { unName :: Text } deriving (P.Eq, P.Show)+newtype BodyOuterComposite = BodyOuterComposite { unBodyOuterComposite :: OuterComposite } deriving (P.Eq, P.Show)++newtype Body = Body { unBody :: OuterNumber } deriving (P.Eq, P.Show)++newtype BodyOuterString = BodyOuterString { unBodyOuterString :: OuterString } deriving (P.Eq, P.Show)++newtype ParamInteger = ParamInteger { unParamInteger :: Int } 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 ParamFloat = ParamFloat { unParamFloat :: Float } deriving (P.Eq, P.Show)++newtype ParamString = ParamString { unParamString :: 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 Password = Password { unPassword :: Text } deriving (P.Eq, P.Show)++newtype Callback = Callback { unCallback :: Text } deriving (P.Eq, P.Show)++newtype EnumFormStringArray = EnumFormStringArray { unEnumFormStringArray :: [Text] } deriving (P.Eq, P.Show)++newtype EnumFormString = EnumFormString { unEnumFormString :: Text } deriving (P.Eq, P.Show)++newtype EnumHeaderStringArray = EnumHeaderStringArray { unEnumHeaderStringArray :: [Text] } deriving (P.Eq, P.Show)++newtype EnumHeaderString = EnumHeaderString { unEnumHeaderString :: Text } deriving (P.Eq, P.Show)++newtype EnumQueryStringArray = EnumQueryStringArray { unEnumQueryStringArray :: [Text] } deriving (P.Eq, P.Show)++newtype EnumQueryString = EnumQueryString { unEnumQueryString :: Text } deriving (P.Eq, P.Show)++newtype EnumQueryInteger = EnumQueryInteger { unEnumQueryInteger :: Int } deriving (P.Eq, P.Show)++newtype EnumQueryDouble = EnumQueryDouble { unEnumQueryDouble :: Double } deriving (P.Eq, P.Show)++newtype ApiKey = ApiKey { unApiKey :: Text } deriving (P.Eq, P.Show)++newtype Name2 = Name2 { unName2 :: Text } deriving (P.Eq, P.Show)  newtype Status = Status { unStatus :: Text } deriving (P.Eq, P.Show) 

@@ -17,6 +17,7 @@ import SwaggerPetstore.Model import SwaggerPetstore.API import SwaggerPetstore.MimeTypes+import SwaggerPetstore.Logging  import qualified Control.Monad.IO.Class as P import qualified Data.Aeson as A@@ -30,8 +31,6 @@ import Web.HttpApiData as WH import Control.Monad.Catch (MonadThrow) -import qualified Control.Monad.Logger as LG- import qualified Data.Time as TI import qualified Data.Map as Map import qualified Data.Text as T@@ -57,8 +56,8 @@ data SwaggerPetstoreConfig = SwaggerPetstoreConfig   { configHost  :: BCL.ByteString -- ^ host supplied in the Request   , configUserAgent :: Text -- ^ user-agent supplied in the Request-  , configExecLoggingT :: ExecLoggingT -- ^ Run a block using a MonadLogger instance-  , configLoggingFilter :: LG.LogSource -> LG.LogLevel -> Bool -- ^ Only log messages passing the given predicate function.+  , configLogExecWithContext :: LogExecWithContext -- ^ Run a block using a Logger instance+  , configLogContext :: LogContext -- ^ Configures the logger   }  -- | display the config@@ -73,35 +72,35 @@ -- -- configHost: ----- @http://petstore.swagger.io/v2@+-- @http://petstore.swagger.io:80/v2@ -- -- configUserAgent: -- -- @"swagger-haskell-http-client/1.0.0"@ ----- configExecLoggingT: 'runNullLoggingT'------ configLoggingFilter: 'infoLevelFilter'-newConfig :: SwaggerPetstoreConfig-newConfig =-  SwaggerPetstoreConfig-  { configHost = "http://petstore.swagger.io/v2"-  , configUserAgent = "swagger-haskell-http-client/1.0.0"-  , configExecLoggingT = runNullLoggingT-  , configLoggingFilter = infoLevelFilter-  }+newConfig :: IO SwaggerPetstoreConfig+newConfig = do+    logCxt <- initLogContext+    return $ SwaggerPetstoreConfig+        { configHost = "http://petstore.swagger.io:80/v2"+        , configUserAgent = "swagger-haskell-http-client/1.0.0"+        , configLogExecWithContext = runDefaultLogExecWithContext+        , configLogContext = logCxt+        }   --- | updates the config to use a MonadLogger instance which prints to stdout.-withStdoutLogging :: SwaggerPetstoreConfig -> SwaggerPetstoreConfig-withStdoutLogging p = p { configExecLoggingT = LG.runStdoutLoggingT}+withStdoutLogging :: SwaggerPetstoreConfig -> IO SwaggerPetstoreConfig+withStdoutLogging p = do+    logCxt <- stdoutLoggingContext (configLogContext p)+    return $ p { configLogExecWithContext = stdoutLoggingExec, configLogContext = logCxt } --- | updates the config to use a MonadLogger instance which prints to stderr.-withStderrLogging :: SwaggerPetstoreConfig -> SwaggerPetstoreConfig-withStderrLogging p = p { configExecLoggingT = LG.runStderrLoggingT}+withStderrLogging :: SwaggerPetstoreConfig -> IO SwaggerPetstoreConfig+withStderrLogging p = do+    logCxt <- stderrLoggingContext (configLogContext p)+    return $ p { configLogExecWithContext = stderrLoggingExec, configLogContext = logCxt }  -- | updates the config to disable logging withNoLogging :: SwaggerPetstoreConfig -> SwaggerPetstoreConfig-withNoLogging p = p { configExecLoggingT = runNullLoggingT}+withNoLogging p = p { configLogExecWithContext =  runNullLogExec}  -- * Dispatch @@ -146,10 +145,10 @@ dispatchMime manager config request accept = do   httpResponse <- dispatchLbs manager config request accept   parsedResult <--    runExceptionLoggingT "Client" config $+    runConfigLogWithExceptions "Client" config $     do case mimeUnrender' accept (NH.responseBody httpResponse) of          Left s -> do-           logNST LG.LevelError "Client" (T.pack s)+           _log "Client" levelError (T.pack s)            pure (Left (MimeError s httpResponse))          Right r -> pure (Right r)   return (MimeResult parsedResult httpResponse)@@ -187,15 +186,15 @@   -> InitRequest req contentType res accept -- ^ init request   -> IO (NH.Response BCL.ByteString) -- ^ response dispatchInitUnsafe manager config (InitRequest req) = do-  runExceptionLoggingT logSrc config $-    do logNST LG.LevelInfo logSrc requestLogMsg-       logNST LG.LevelDebug logSrc requestDbgLogMsg+  runConfigLogWithExceptions src config $+    do _log src levelInfo requestLogMsg+       _log src levelDebug requestDbgLogMsg        res <- P.liftIO $ NH.httpLbs req manager-       logNST LG.LevelInfo logSrc (responseLogMsg res)-       logNST LG.LevelDebug logSrc ((T.pack . show) res)+       _log src levelInfo (responseLogMsg res)+       _log src levelDebug ((T.pack . show) res)        return res   where-    logSrc = "Client"+    src = "Client"     endpoint =       T.pack $       BC.unpack $@@ -250,68 +249,16 @@ modifyInitRequestM :: Monad m => InitRequest req contentType res accept -> (NH.Request -> m NH.Request) -> m (InitRequest req contentType res accept) modifyInitRequestM (InitRequest req) f = fmap InitRequest (f req) --- * Logging---- | A block using a MonadLogger instance-type ExecLoggingT = forall m. P.MonadIO m =>-                              forall a. LG.LoggingT m a -> m a---- ** Null Logger---- | a logger which disables logging-nullLogger :: LG.Loc -> LG.LogSource -> LG.LogLevel -> LG.LogStr -> IO ()-nullLogger _ _ _ _ = return ()---- | run the monad transformer that disables logging-runNullLoggingT :: LG.LoggingT m a -> m a-runNullLoggingT = (`LG.runLoggingT` nullLogger)---- ** Logging Filters---- | a log filter that uses 'LevelError' as the minimum logging level-errorLevelFilter :: LG.LogSource -> LG.LogLevel -> Bool-errorLevelFilter = minLevelFilter LG.LevelError---- | a log filter that uses 'LevelInfo' as the minimum logging level-infoLevelFilter :: LG.LogSource -> LG.LogLevel -> Bool-infoLevelFilter = minLevelFilter LG.LevelInfo---- | a log filter that uses 'LevelDebug' as the minimum logging level-debugLevelFilter :: LG.LogSource -> LG.LogLevel -> Bool-debugLevelFilter = minLevelFilter LG.LevelDebug--minLevelFilter :: LG.LogLevel -> LG.LogSource -> LG.LogLevel -> Bool-minLevelFilter l _ l' = l' >= l- -- ** Logging  --- | Log a message using the current time-logNST :: (P.MonadIO m, LG.MonadLogger m) => LG.LogLevel -> Text -> Text -> m ()-logNST level src msg = do-  now <- P.liftIO (formatTimeLog <$> TI.getCurrentTime)-  LG.logOtherNS sourceLog level (now <> " " <> msg)- where-  sourceLog = "SwaggerPetstore/" <> src-  formatTimeLog =-    T.pack . TI.formatTime TI.defaultTimeLocale "%Y-%m-%dT%H:%M:%S%Z"---- | re-throws exceptions after logging them-logExceptions-  :: (LG.MonadLogger m, E.MonadCatch m, P.MonadIO m)-  => Text -> m a -> m a-logExceptions src =-  E.handle-    (\(e :: E.SomeException) -> do-       logNST LG.LevelError src ((T.pack . show) e)-       E.throw e)---- | Run a block using the configured MonadLogger instance-runLoggingT :: SwaggerPetstoreConfig -> ExecLoggingT-runLoggingT config =-  configExecLoggingT config . LG.filterLogger (configLoggingFilter config)+-- | Run a block using the configured logger instance+runConfigLog+  :: P.MonadIO m+  => SwaggerPetstoreConfig -> LogExec m+runConfigLog config = configLogExecWithContext config (configLogContext config) --- | Run a block using the configured MonadLogger instance (logs exceptions)-runExceptionLoggingT+-- | Run a block using the configured logger instance (logs exceptions)+runConfigLogWithExceptions   :: (E.MonadCatch m, P.MonadIO m)-  => T.Text -> SwaggerPetstoreConfig -> LG.LoggingT m a -> m a-runExceptionLoggingT logSrc config = runLoggingT config . logExceptions logSrc+  => T.Text -> SwaggerPetstoreConfig -> LogExec m+runConfigLogWithExceptions src config = runConfigLog config . logExceptions src

@@ -10,18 +10,15 @@  module SwaggerPetstore.Lens where -import Data.Text (Text)- import qualified Data.Aeson as A-import Data.Aeson (Value)-import qualified Data.ByteString as B-import Data.ByteString.Lazy (ByteString)+import qualified Data.ByteString.Lazy as BL import qualified Data.Data as P (Data, Typeable) import qualified Data.Map as Map-+import qualified Data.Set as Set import qualified Data.Time as TI-import Data.Time (UTCTime) +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 @@ -33,6 +30,38 @@ type Lens_ s t a b = forall (f :: * -> *). Functor f => (a -> f b) -> s -> f t  +-- * AdditionalPropertiesClass++-- | 'additionalPropertiesClassMapProperty' Lens+additionalPropertiesClassMapPropertyL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Text))+additionalPropertiesClassMapPropertyL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapProperty -> AdditionalPropertiesClass { additionalPropertiesClassMapProperty, ..} ) <$> f additionalPropertiesClassMapProperty+{-# INLINE additionalPropertiesClassMapPropertyL #-}++-- | 'additionalPropertiesClassMapOfMapProperty' Lens+additionalPropertiesClassMapOfMapPropertyL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String (Map.Map String Text)))+additionalPropertiesClassMapOfMapPropertyL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapOfMapProperty -> AdditionalPropertiesClass { additionalPropertiesClassMapOfMapProperty, ..} ) <$> f additionalPropertiesClassMapOfMapProperty+{-# INLINE additionalPropertiesClassMapOfMapPropertyL #-}++++-- * Animal++-- | 'animalClassName' Lens+animalClassNameL :: Lens_' Animal (Text)+animalClassNameL f Animal{..} = (\animalClassName -> Animal { animalClassName, ..} ) <$> f animalClassName+{-# INLINE animalClassNameL #-}++-- | 'animalColor' Lens+animalColorL :: Lens_' Animal (Maybe Text)+animalColorL f Animal{..} = (\animalColor -> Animal { animalColor, ..} ) <$> f animalColor+{-# INLINE animalColorL #-}++++-- * AnimalFarm+++ -- * ApiResponse  -- | 'apiResponseCode' Lens@@ -52,6 +81,77 @@   +-- * ArrayOfArrayOfNumberOnly++-- | 'arrayOfArrayOfNumberOnlyArrayArrayNumber' Lens+arrayOfArrayOfNumberOnlyArrayArrayNumberL :: Lens_' ArrayOfArrayOfNumberOnly (Maybe [[Double]])+arrayOfArrayOfNumberOnlyArrayArrayNumberL f ArrayOfArrayOfNumberOnly{..} = (\arrayOfArrayOfNumberOnlyArrayArrayNumber -> ArrayOfArrayOfNumberOnly { arrayOfArrayOfNumberOnlyArrayArrayNumber, ..} ) <$> f arrayOfArrayOfNumberOnlyArrayArrayNumber+{-# INLINE arrayOfArrayOfNumberOnlyArrayArrayNumberL #-}++++-- * ArrayOfNumberOnly++-- | 'arrayOfNumberOnlyArrayNumber' Lens+arrayOfNumberOnlyArrayNumberL :: Lens_' ArrayOfNumberOnly (Maybe [Double])+arrayOfNumberOnlyArrayNumberL f ArrayOfNumberOnly{..} = (\arrayOfNumberOnlyArrayNumber -> ArrayOfNumberOnly { arrayOfNumberOnlyArrayNumber, ..} ) <$> f arrayOfNumberOnlyArrayNumber+{-# INLINE arrayOfNumberOnlyArrayNumberL #-}++++-- * ArrayTest++-- | 'arrayTestArrayOfString' Lens+arrayTestArrayOfStringL :: Lens_' ArrayTest (Maybe [Text])+arrayTestArrayOfStringL f ArrayTest{..} = (\arrayTestArrayOfString -> ArrayTest { arrayTestArrayOfString, ..} ) <$> f arrayTestArrayOfString+{-# INLINE arrayTestArrayOfStringL #-}++-- | 'arrayTestArrayArrayOfInteger' Lens+arrayTestArrayArrayOfIntegerL :: Lens_' ArrayTest (Maybe [[Integer]])+arrayTestArrayArrayOfIntegerL f ArrayTest{..} = (\arrayTestArrayArrayOfInteger -> ArrayTest { arrayTestArrayArrayOfInteger, ..} ) <$> f arrayTestArrayArrayOfInteger+{-# INLINE arrayTestArrayArrayOfIntegerL #-}++-- | 'arrayTestArrayArrayOfModel' Lens+arrayTestArrayArrayOfModelL :: Lens_' ArrayTest (Maybe [[ReadOnlyFirst]])+arrayTestArrayArrayOfModelL f ArrayTest{..} = (\arrayTestArrayArrayOfModel -> ArrayTest { arrayTestArrayArrayOfModel, ..} ) <$> f arrayTestArrayArrayOfModel+{-# INLINE arrayTestArrayArrayOfModelL #-}++++-- * Capitalization++-- | 'capitalizationSmallCamel' Lens+capitalizationSmallCamelL :: Lens_' Capitalization (Maybe Text)+capitalizationSmallCamelL f Capitalization{..} = (\capitalizationSmallCamel -> Capitalization { capitalizationSmallCamel, ..} ) <$> f capitalizationSmallCamel+{-# INLINE capitalizationSmallCamelL #-}++-- | 'capitalizationCapitalCamel' Lens+capitalizationCapitalCamelL :: Lens_' Capitalization (Maybe Text)+capitalizationCapitalCamelL f Capitalization{..} = (\capitalizationCapitalCamel -> Capitalization { capitalizationCapitalCamel, ..} ) <$> f capitalizationCapitalCamel+{-# INLINE capitalizationCapitalCamelL #-}++-- | 'capitalizationSmallSnake' Lens+capitalizationSmallSnakeL :: Lens_' Capitalization (Maybe Text)+capitalizationSmallSnakeL f Capitalization{..} = (\capitalizationSmallSnake -> Capitalization { capitalizationSmallSnake, ..} ) <$> f capitalizationSmallSnake+{-# INLINE capitalizationSmallSnakeL #-}++-- | 'capitalizationCapitalSnake' Lens+capitalizationCapitalSnakeL :: Lens_' Capitalization (Maybe Text)+capitalizationCapitalSnakeL f Capitalization{..} = (\capitalizationCapitalSnake -> Capitalization { capitalizationCapitalSnake, ..} ) <$> f capitalizationCapitalSnake+{-# INLINE capitalizationCapitalSnakeL #-}++-- | 'capitalizationScaEthFlowPoints' Lens+capitalizationScaEthFlowPointsL :: Lens_' Capitalization (Maybe Text)+capitalizationScaEthFlowPointsL f Capitalization{..} = (\capitalizationScaEthFlowPoints -> Capitalization { capitalizationScaEthFlowPoints, ..} ) <$> f capitalizationScaEthFlowPoints+{-# INLINE capitalizationScaEthFlowPointsL #-}++-- | 'capitalizationAttName' Lens+capitalizationAttNameL :: Lens_' Capitalization (Maybe Text)+capitalizationAttNameL f Capitalization{..} = (\capitalizationAttName -> Capitalization { capitalizationAttName, ..} ) <$> f capitalizationAttName+{-# INLINE capitalizationAttNameL #-}+++ -- * Category  -- | 'categoryId' Lens@@ -66,6 +166,247 @@   +-- * ClassModel++-- | 'classModelClass' Lens+classModelClassL :: Lens_' ClassModel (Maybe Text)+classModelClassL f ClassModel{..} = (\classModelClass -> ClassModel { classModelClass, ..} ) <$> f classModelClass+{-# INLINE classModelClassL #-}++++-- * Client++-- | 'clientClient' Lens+clientClientL :: Lens_' Client (Maybe Text)+clientClientL f Client{..} = (\clientClient -> Client { clientClient, ..} ) <$> f clientClient+{-# INLINE clientClientL #-}++++-- * EnumArrays++-- | 'enumArraysJustSymbol' Lens+enumArraysJustSymbolL :: Lens_' EnumArrays (Maybe Text)+enumArraysJustSymbolL f EnumArrays{..} = (\enumArraysJustSymbol -> EnumArrays { enumArraysJustSymbol, ..} ) <$> f enumArraysJustSymbol+{-# INLINE enumArraysJustSymbolL #-}++-- | 'enumArraysArrayEnum' Lens+enumArraysArrayEnumL :: Lens_' EnumArrays (Maybe [Text])+enumArraysArrayEnumL f EnumArrays{..} = (\enumArraysArrayEnum -> EnumArrays { enumArraysArrayEnum, ..} ) <$> f enumArraysArrayEnum+{-# INLINE enumArraysArrayEnumL #-}++++-- * EnumClass++++-- * EnumTest++-- | 'enumTestEnumString' Lens+enumTestEnumStringL :: Lens_' EnumTest (Maybe Text)+enumTestEnumStringL f EnumTest{..} = (\enumTestEnumString -> EnumTest { enumTestEnumString, ..} ) <$> f enumTestEnumString+{-# INLINE enumTestEnumStringL #-}++-- | 'enumTestEnumInteger' Lens+enumTestEnumIntegerL :: Lens_' EnumTest (Maybe Int)+enumTestEnumIntegerL f EnumTest{..} = (\enumTestEnumInteger -> EnumTest { enumTestEnumInteger, ..} ) <$> f enumTestEnumInteger+{-# INLINE enumTestEnumIntegerL #-}++-- | 'enumTestEnumNumber' Lens+enumTestEnumNumberL :: Lens_' EnumTest (Maybe Double)+enumTestEnumNumberL f EnumTest{..} = (\enumTestEnumNumber -> EnumTest { enumTestEnumNumber, ..} ) <$> f enumTestEnumNumber+{-# INLINE enumTestEnumNumberL #-}++-- | 'enumTestOuterEnum' Lens+enumTestOuterEnumL :: Lens_' EnumTest (Maybe OuterEnum)+enumTestOuterEnumL f EnumTest{..} = (\enumTestOuterEnum -> EnumTest { enumTestOuterEnum, ..} ) <$> f enumTestOuterEnum+{-# INLINE enumTestOuterEnumL #-}++++-- * FormatTest++-- | 'formatTestInteger' Lens+formatTestIntegerL :: Lens_' FormatTest (Maybe Int)+formatTestIntegerL f FormatTest{..} = (\formatTestInteger -> FormatTest { formatTestInteger, ..} ) <$> f formatTestInteger+{-# INLINE formatTestIntegerL #-}++-- | 'formatTestInt32' Lens+formatTestInt32L :: Lens_' FormatTest (Maybe Int)+formatTestInt32L f FormatTest{..} = (\formatTestInt32 -> FormatTest { formatTestInt32, ..} ) <$> f formatTestInt32+{-# INLINE formatTestInt32L #-}++-- | 'formatTestInt64' Lens+formatTestInt64L :: Lens_' FormatTest (Maybe Integer)+formatTestInt64L f FormatTest{..} = (\formatTestInt64 -> FormatTest { formatTestInt64, ..} ) <$> f formatTestInt64+{-# INLINE formatTestInt64L #-}++-- | 'formatTestNumber' Lens+formatTestNumberL :: Lens_' FormatTest (Double)+formatTestNumberL f FormatTest{..} = (\formatTestNumber -> FormatTest { formatTestNumber, ..} ) <$> f formatTestNumber+{-# INLINE formatTestNumberL #-}++-- | 'formatTestFloat' Lens+formatTestFloatL :: Lens_' FormatTest (Maybe Float)+formatTestFloatL f FormatTest{..} = (\formatTestFloat -> FormatTest { formatTestFloat, ..} ) <$> f formatTestFloat+{-# INLINE formatTestFloatL #-}++-- | 'formatTestDouble' Lens+formatTestDoubleL :: Lens_' FormatTest (Maybe Double)+formatTestDoubleL f FormatTest{..} = (\formatTestDouble -> FormatTest { formatTestDouble, ..} ) <$> f formatTestDouble+{-# INLINE formatTestDoubleL #-}++-- | 'formatTestString' Lens+formatTestStringL :: Lens_' FormatTest (Maybe Text)+formatTestStringL f FormatTest{..} = (\formatTestString -> FormatTest { formatTestString, ..} ) <$> f formatTestString+{-# INLINE formatTestStringL #-}++-- | 'formatTestByte' Lens+formatTestByteL :: Lens_' FormatTest (ByteArray)+formatTestByteL f FormatTest{..} = (\formatTestByte -> FormatTest { formatTestByte, ..} ) <$> f formatTestByte+{-# INLINE formatTestByteL #-}++-- | 'formatTestBinary' Lens+formatTestBinaryL :: Lens_' FormatTest (Maybe Binary)+formatTestBinaryL f FormatTest{..} = (\formatTestBinary -> FormatTest { formatTestBinary, ..} ) <$> f formatTestBinary+{-# INLINE formatTestBinaryL #-}++-- | 'formatTestDate' Lens+formatTestDateL :: Lens_' FormatTest (Date)+formatTestDateL f FormatTest{..} = (\formatTestDate -> FormatTest { formatTestDate, ..} ) <$> f formatTestDate+{-# INLINE formatTestDateL #-}++-- | 'formatTestDateTime' Lens+formatTestDateTimeL :: Lens_' FormatTest (Maybe DateTime)+formatTestDateTimeL f FormatTest{..} = (\formatTestDateTime -> FormatTest { formatTestDateTime, ..} ) <$> f formatTestDateTime+{-# INLINE formatTestDateTimeL #-}++-- | 'formatTestUuid' Lens+formatTestUuidL :: Lens_' FormatTest (Maybe Text)+formatTestUuidL f FormatTest{..} = (\formatTestUuid -> FormatTest { formatTestUuid, ..} ) <$> f formatTestUuid+{-# INLINE formatTestUuidL #-}++-- | 'formatTestPassword' Lens+formatTestPasswordL :: Lens_' FormatTest (Text)+formatTestPasswordL f FormatTest{..} = (\formatTestPassword -> FormatTest { formatTestPassword, ..} ) <$> f formatTestPassword+{-# INLINE formatTestPasswordL #-}++++-- * HasOnlyReadOnly++-- | 'hasOnlyReadOnlyBar' Lens+hasOnlyReadOnlyBarL :: Lens_' HasOnlyReadOnly (Maybe Text)+hasOnlyReadOnlyBarL f HasOnlyReadOnly{..} = (\hasOnlyReadOnlyBar -> HasOnlyReadOnly { hasOnlyReadOnlyBar, ..} ) <$> f hasOnlyReadOnlyBar+{-# INLINE hasOnlyReadOnlyBarL #-}++-- | 'hasOnlyReadOnlyFoo' Lens+hasOnlyReadOnlyFooL :: Lens_' HasOnlyReadOnly (Maybe Text)+hasOnlyReadOnlyFooL f HasOnlyReadOnly{..} = (\hasOnlyReadOnlyFoo -> HasOnlyReadOnly { hasOnlyReadOnlyFoo, ..} ) <$> f hasOnlyReadOnlyFoo+{-# INLINE hasOnlyReadOnlyFooL #-}++++-- * MapTest++-- | 'mapTestMapMapOfString' Lens+mapTestMapMapOfStringL :: Lens_' MapTest (Maybe (Map.Map String (Map.Map String Text)))+mapTestMapMapOfStringL f MapTest{..} = (\mapTestMapMapOfString -> MapTest { mapTestMapMapOfString, ..} ) <$> f mapTestMapMapOfString+{-# INLINE mapTestMapMapOfStringL #-}++-- | 'mapTestMapOfEnumString' Lens+mapTestMapOfEnumStringL :: Lens_' MapTest (Maybe (Map.Map String Text))+mapTestMapOfEnumStringL f MapTest{..} = (\mapTestMapOfEnumString -> MapTest { mapTestMapOfEnumString, ..} ) <$> f mapTestMapOfEnumString+{-# INLINE mapTestMapOfEnumStringL #-}++++-- * MixedPropertiesAndAdditionalPropertiesClass++-- | 'mixedPropertiesAndAdditionalPropertiesClassUuid' Lens+mixedPropertiesAndAdditionalPropertiesClassUuidL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe Text)+mixedPropertiesAndAdditionalPropertiesClassUuidL f MixedPropertiesAndAdditionalPropertiesClass{..} = (\mixedPropertiesAndAdditionalPropertiesClassUuid -> MixedPropertiesAndAdditionalPropertiesClass { mixedPropertiesAndAdditionalPropertiesClassUuid, ..} ) <$> f mixedPropertiesAndAdditionalPropertiesClassUuid+{-# INLINE mixedPropertiesAndAdditionalPropertiesClassUuidL #-}++-- | 'mixedPropertiesAndAdditionalPropertiesClassDateTime' Lens+mixedPropertiesAndAdditionalPropertiesClassDateTimeL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe DateTime)+mixedPropertiesAndAdditionalPropertiesClassDateTimeL f MixedPropertiesAndAdditionalPropertiesClass{..} = (\mixedPropertiesAndAdditionalPropertiesClassDateTime -> MixedPropertiesAndAdditionalPropertiesClass { mixedPropertiesAndAdditionalPropertiesClassDateTime, ..} ) <$> f mixedPropertiesAndAdditionalPropertiesClassDateTime+{-# INLINE mixedPropertiesAndAdditionalPropertiesClassDateTimeL #-}++-- | 'mixedPropertiesAndAdditionalPropertiesClassMap' Lens+mixedPropertiesAndAdditionalPropertiesClassMapL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe (Map.Map String Animal))+mixedPropertiesAndAdditionalPropertiesClassMapL f MixedPropertiesAndAdditionalPropertiesClass{..} = (\mixedPropertiesAndAdditionalPropertiesClassMap -> MixedPropertiesAndAdditionalPropertiesClass { mixedPropertiesAndAdditionalPropertiesClassMap, ..} ) <$> f mixedPropertiesAndAdditionalPropertiesClassMap+{-# INLINE mixedPropertiesAndAdditionalPropertiesClassMapL #-}++++-- * Model200Response++-- | 'model200ResponseName' Lens+model200ResponseNameL :: Lens_' Model200Response (Maybe Int)+model200ResponseNameL f Model200Response{..} = (\model200ResponseName -> Model200Response { model200ResponseName, ..} ) <$> f model200ResponseName+{-# INLINE model200ResponseNameL #-}++-- | 'model200ResponseClass' Lens+model200ResponseClassL :: Lens_' Model200Response (Maybe Text)+model200ResponseClassL f Model200Response{..} = (\model200ResponseClass -> Model200Response { model200ResponseClass, ..} ) <$> f model200ResponseClass+{-# INLINE model200ResponseClassL #-}++++-- * ModelList++-- | 'modelList123List' Lens+modelList123ListL :: Lens_' ModelList (Maybe Text)+modelList123ListL f ModelList{..} = (\modelList123List -> ModelList { modelList123List, ..} ) <$> f modelList123List+{-# INLINE modelList123ListL #-}++++-- * ModelReturn++-- | 'modelReturnReturn' Lens+modelReturnReturnL :: Lens_' ModelReturn (Maybe Int)+modelReturnReturnL f ModelReturn{..} = (\modelReturnReturn -> ModelReturn { modelReturnReturn, ..} ) <$> f modelReturnReturn+{-# INLINE modelReturnReturnL #-}++++-- * Name++-- | 'nameName' Lens+nameNameL :: Lens_' Name (Int)+nameNameL f Name{..} = (\nameName -> Name { nameName, ..} ) <$> f nameName+{-# INLINE nameNameL #-}++-- | 'nameSnakeCase' Lens+nameSnakeCaseL :: Lens_' Name (Maybe Int)+nameSnakeCaseL f Name{..} = (\nameSnakeCase -> Name { nameSnakeCase, ..} ) <$> f nameSnakeCase+{-# INLINE nameSnakeCaseL #-}++-- | 'nameProperty' Lens+namePropertyL :: Lens_' Name (Maybe Text)+namePropertyL f Name{..} = (\nameProperty -> Name { nameProperty, ..} ) <$> f nameProperty+{-# INLINE namePropertyL #-}++-- | 'name123Number' Lens+name123NumberL :: Lens_' Name (Maybe Int)+name123NumberL f Name{..} = (\name123Number -> Name { name123Number, ..} ) <$> f name123Number+{-# INLINE name123NumberL #-}++++-- * NumberOnly++-- | 'numberOnlyJustNumber' Lens+numberOnlyJustNumberL :: Lens_' NumberOnly (Maybe Double)+numberOnlyJustNumberL f NumberOnly{..} = (\numberOnlyJustNumber -> NumberOnly { numberOnlyJustNumber, ..} ) <$> f numberOnlyJustNumber+{-# INLINE numberOnlyJustNumberL #-}+++ -- * Order  -- | 'orderId' Lens@@ -84,7 +425,7 @@ {-# INLINE orderQuantityL #-}  -- | 'orderShipDate' Lens-orderShipDateL :: Lens_' Order (Maybe UTCTime)+orderShipDateL :: Lens_' Order (Maybe DateTime) orderShipDateL f Order{..} = (\orderShipDate -> Order { orderShipDate, ..} ) <$> f orderShipDate {-# INLINE orderShipDateL #-} @@ -100,6 +441,41 @@   +-- * OuterBoolean++++-- * OuterComposite++-- | 'outerCompositeMyNumber' Lens+outerCompositeMyNumberL :: Lens_' OuterComposite (Maybe OuterNumber)+outerCompositeMyNumberL f OuterComposite{..} = (\outerCompositeMyNumber -> OuterComposite { outerCompositeMyNumber, ..} ) <$> f outerCompositeMyNumber+{-# INLINE outerCompositeMyNumberL #-}++-- | 'outerCompositeMyString' Lens+outerCompositeMyStringL :: Lens_' OuterComposite (Maybe OuterString)+outerCompositeMyStringL f OuterComposite{..} = (\outerCompositeMyString -> OuterComposite { outerCompositeMyString, ..} ) <$> f outerCompositeMyString+{-# INLINE outerCompositeMyStringL #-}++-- | 'outerCompositeMyBoolean' Lens+outerCompositeMyBooleanL :: Lens_' OuterComposite (Maybe OuterBoolean)+outerCompositeMyBooleanL f OuterComposite{..} = (\outerCompositeMyBoolean -> OuterComposite { outerCompositeMyBoolean, ..} ) <$> f outerCompositeMyBoolean+{-# INLINE outerCompositeMyBooleanL #-}++++-- * OuterEnum++++-- * OuterNumber++++-- * OuterString+++ -- * Pet  -- | 'petId' Lens@@ -134,6 +510,29 @@   +-- * ReadOnlyFirst++-- | 'readOnlyFirstBar' Lens+readOnlyFirstBarL :: Lens_' ReadOnlyFirst (Maybe Text)+readOnlyFirstBarL f ReadOnlyFirst{..} = (\readOnlyFirstBar -> ReadOnlyFirst { readOnlyFirstBar, ..} ) <$> f readOnlyFirstBar+{-# INLINE readOnlyFirstBarL #-}++-- | 'readOnlyFirstBaz' Lens+readOnlyFirstBazL :: Lens_' ReadOnlyFirst (Maybe Text)+readOnlyFirstBazL f ReadOnlyFirst{..} = (\readOnlyFirstBaz -> ReadOnlyFirst { readOnlyFirstBaz, ..} ) <$> f readOnlyFirstBaz+{-# INLINE readOnlyFirstBazL #-}++++-- * SpecialModelName++-- | 'specialModelNameSpecialPropertyName' Lens+specialModelNameSpecialPropertyNameL :: Lens_' SpecialModelName (Maybe Integer)+specialModelNameSpecialPropertyNameL f SpecialModelName{..} = (\specialModelNameSpecialPropertyName -> SpecialModelName { specialModelNameSpecialPropertyName, ..} ) <$> f specialModelNameSpecialPropertyName+{-# INLINE specialModelNameSpecialPropertyNameL #-}+++ -- * Tag  -- | 'tagId' Lens@@ -189,5 +588,43 @@ userUserStatusL :: Lens_' User (Maybe Int) userUserStatusL f User{..} = (\userUserStatus -> User { userUserStatus, ..} ) <$> f userUserStatus {-# INLINE userUserStatusL #-}++++-- * Cat++-- | 'catClassName' Lens+catClassNameL :: Lens_' Cat (Text)+catClassNameL f Cat{..} = (\catClassName -> Cat { catClassName, ..} ) <$> f catClassName+{-# INLINE catClassNameL #-}++-- | 'catColor' Lens+catColorL :: Lens_' Cat (Maybe Text)+catColorL f Cat{..} = (\catColor -> Cat { catColor, ..} ) <$> f catColor+{-# INLINE catColorL #-}++-- | 'catDeclawed' Lens+catDeclawedL :: Lens_' Cat (Maybe Bool)+catDeclawedL f Cat{..} = (\catDeclawed -> Cat { catDeclawed, ..} ) <$> f catDeclawed+{-# INLINE catDeclawedL #-}++++-- * Dog++-- | 'dogClassName' Lens+dogClassNameL :: Lens_' Dog (Text)+dogClassNameL f Dog{..} = (\dogClassName -> Dog { dogClassName, ..} ) <$> f dogClassName+{-# INLINE dogClassNameL #-}++-- | 'dogColor' Lens+dogColorL :: Lens_' Dog (Maybe Text)+dogColorL f Dog{..} = (\dogColor -> Dog { dogColor, ..} ) <$> f dogColor+{-# INLINE dogColorL #-}++-- | 'dogBreed' Lens+dogBreedL :: Lens_' Dog (Maybe Text)+dogBreedL f Dog{..} = (\dogBreed -> Dog { dogBreed, ..} ) <$> f dogBreed+{-# INLINE dogBreedL #-}  

@@ -0,0 +1,108 @@+{-|+Module : SwaggerPetstore.Logging+Katip Logging functions+-}++{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}++module SwaggerPetstore.Logging where++import Data.Text (Text)+import GHC.Exts (IsString(..))++import qualified Control.Exception.Safe as E+import qualified Control.Monad.IO.Class as P+import qualified Control.Monad.Trans.Reader as P+import qualified Data.Text as T+import qualified Lens.Micro as L+import qualified System.IO as IO++import qualified Katip as LG++-- * Type Aliases (for compatability)++-- | Runs a Katip logging block with the Log environment+type LogExecWithContext = forall m. P.MonadIO m =>+                                    LogContext -> LogExec m++-- | A Katip logging block+type LogExec m = forall a. LG.KatipT m a -> m a++-- | A Katip Log environment+type LogContext = LG.LogEnv++-- | A Katip Log severity+type LogLevel = LG.Severity++-- * default logger++-- | the default log environment+initLogContext :: IO LogContext+initLogContext = LG.initLogEnv "SwaggerPetstore" "dev"++-- | Runs a Katip logging block with the Log environment+runDefaultLogExecWithContext :: LogExecWithContext+runDefaultLogExecWithContext = LG.runKatipT++-- * stdout logger++-- | Runs a Katip logging block with the Log environment+stdoutLoggingExec :: LogExecWithContext+stdoutLoggingExec = runDefaultLogExecWithContext++-- | A Katip Log environment which targets stdout+stdoutLoggingContext :: LogContext -> IO LogContext+stdoutLoggingContext cxt = do+    handleScribe <- LG.mkHandleScribe LG.ColorIfTerminal IO.stdout LG.InfoS LG.V2+    LG.registerScribe "stdout" handleScribe LG.defaultScribeSettings cxt++-- * stderr logger++-- | Runs a Katip logging block with the Log environment+stderrLoggingExec :: LogExecWithContext+stderrLoggingExec = runDefaultLogExecWithContext++-- | A Katip Log environment which targets stderr+stderrLoggingContext :: LogContext -> IO LogContext+stderrLoggingContext cxt = do+    handleScribe <- LG.mkHandleScribe LG.ColorIfTerminal IO.stderr LG.InfoS LG.V2+    LG.registerScribe "stderr" handleScribe LG.defaultScribeSettings cxt++-- * Null logger++-- | Disables Katip logging+runNullLogExec :: LogExecWithContext+runNullLogExec le (LG.KatipT f) = P.runReaderT f (L.set LG.logEnvScribes mempty le)++-- * Log Msg++-- | Log a katip message+_log :: (Applicative m, LG.Katip m) => Text -> LogLevel -> Text -> m ()+_log src level msg = do+  LG.logMsg (fromString $ T.unpack src) level (LG.logStr msg)++-- * Log Exceptions++-- | re-throws exceptions after logging them+logExceptions+  :: (LG.Katip m, E.MonadCatch m, Applicative m)+  => Text -> m a -> m a+logExceptions src =+  E.handle+    (\(e :: E.SomeException) -> do+       _log src LG.ErrorS ((T.pack . show) e)+       E.throw e)++-- * Log Level++levelInfo :: LogLevel+levelInfo = LG.InfoS++levelError :: LogLevel+levelError = LG.ErrorS++levelDebug :: LogLevel+levelDebug = LG.DebugS+

@@ -13,6 +13,7 @@  module SwaggerPetstore.MimeTypes where +import SwaggerPetstore.Model as M  import qualified Data.Aeson as A @@ -22,13 +23,16 @@ import qualified Data.ByteString.Char8 as BC import qualified Data.ByteString.Lazy.Char8 as BCL + import qualified Network.HTTP.Media as ME  import qualified Web.FormUrlEncoded as WH+import qualified Web.HttpApiData as WH  import qualified Data.Data as P (Typeable) import qualified Data.Proxy as P (Proxy(..)) import qualified Data.Text as T+import qualified Data.String as P import qualified Data.Text.Encoding as T import qualified Control.Arrow as P (left) @@ -50,7 +54,10 @@ data MimeMultipartFormData = MimeMultipartFormData deriving (P.Typeable) data MimeOctetStream = MimeOctetStream deriving (P.Typeable) data MimeNoContent = MimeNoContent deriving (P.Typeable)+data MimeAny = MimeAny deriving (P.Typeable) +data MimeXmlCharsetutf8 = MimeXmlCharsetutf8 deriving (P.Typeable)+data MimeJsonCharsetutf8 = MimeJsonCharsetutf8 deriving (P.Typeable)  -- ** MimeType Class @@ -76,34 +83,41 @@  -- ** MimeType Instances --- | @application/json@+-- | @application/json; charset=utf-8@ instance MimeType MimeJSON where-  mimeTypes _ =-    [ "application" ME.// "json" ME./: ("charset", "utf-8")-    , "application" ME.// "json"-    ]---- | @application/xml@+  mimeType _ = Just $ P.fromString "application/json"+-- | @application/xml; charset=utf-8@ instance MimeType MimeXML where-  mimeType _ = Just $ "application" ME.// "xml"-+  mimeType _ = Just $ P.fromString "application/xml" -- | @application/x-www-form-urlencoded@ instance MimeType MimeFormUrlEncoded where-  mimeType _ = Just $ "application" ME.// "x-www-form-urlencoded"-+  mimeType _ = Just $ P.fromString "application/x-www-form-urlencoded" -- | @multipart/form-data@ instance MimeType MimeMultipartFormData where-  mimeType _ = Just $ "multipart" ME.// "form-data"---- | @text/plain;charset=utf-8@+  mimeType _ = Just $ P.fromString "multipart/form-data"+-- | @text/plain; charset=utf-8@ instance MimeType MimePlainText where-  mimeType _ = Just $ "text" ME.// "plain" ME./: ("charset", "utf-8")+  mimeType _ = Just $ P.fromString "text/plain"+-- | @application/octet-stream@ instance MimeType MimeOctetStream where-  mimeType _ = Just $ "application" ME.// "octet-stream"+  mimeType _ = Just $ P.fromString "application/octet-stream"+-- | @"*/*"@+instance MimeType MimeAny where+  mimeType _ = Just $ P.fromString "*/*" instance MimeType MimeNoContent where   mimeType _ = Nothing +-- | @application/xml; charset=utf-8@+instance MimeType MimeXmlCharsetutf8 where+  mimeType _ = Just $ P.fromString "application/xml; charset=utf-8" +-- | @application/json; charset=utf-8@+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++ -- ** MimeRender Class  class MimeType mtype => MimeRender mtype x where@@ -133,13 +147,24 @@ -- | @BCL.pack@ instance MimeRender MimeOctetStream String where mimeRender _ = BCL.pack --- | @P.id@ instance MimeRender MimeMultipartFormData BL.ByteString where mimeRender _ = P.id--- | @BL.fromStrict . T.encodeUtf8@-instance MimeRender MimeMultipartFormData T.Text where mimeRender _ = BL.fromStrict . T.encodeUtf8--- | @BCL.pack@-instance MimeRender MimeMultipartFormData String where mimeRender _ = BCL.pack+instance MimeRender MimeMultipartFormData Binary where mimeRender _ = unBinary +instance MimeRender MimeMultipartFormData ByteArray where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData Bool where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData Char where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData Date where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData DateTime where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData Double where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData Float where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData Int where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData Integer where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData String where mimeRender _ = mimeRenderDefaultMultipartFormData+instance MimeRender MimeMultipartFormData T.Text where mimeRender _ = mimeRenderDefaultMultipartFormData++mimeRenderDefaultMultipartFormData :: WH.ToHttpApiData a => a -> BL.ByteString+mimeRenderDefaultMultipartFormData = BL.fromStrict . T.encodeUtf8 . WH.toQueryParam+ -- | @P.Right . P.const NoContent@ instance MimeRender MimeNoContent NoContent where mimeRender _ = P.const BCL.empty @@ -148,6 +173,8 @@ -- instance MimeRender MimeOctetStream Int where mimeRender _ = BB.toLazyByteString . BB.intDec -- instance MimeRender MimeOctetStream Integer where mimeRender _ = BB.toLazyByteString . BB.integerDec +-- instance MimeRender MimeXmlCharsetutf8 T.Text where mimeRender _ = undefined+-- instance MimeRender MimeJsonCharsetutf8 T.Text where mimeRender _ = undefined  -- ** MimeUnrender Class @@ -180,6 +207,8 @@ -- | @P.Right . P.const NoContent@ instance MimeUnrender MimeNoContent NoContent where mimeUnrender _ = P.Right . P.const NoContent +-- instance MimeUnrender MimeXmlCharsetutf8 T.Text where mimeUnrender _ = undefined+-- instance MimeUnrender MimeJsonCharsetutf8 T.Text where mimeUnrender _ = undefined  -- ** Request Consumes 

@@ -17,361 +17,1400 @@ module SwaggerPetstore.Model where  import Data.Aeson ((.:),(.:!),(.:?),(.=))-import Data.Text (Text)--import Data.Aeson (Value)-import Data.ByteString.Lazy (ByteString)--import qualified Data.Aeson as A-import qualified Data.ByteString as B-import qualified Data.Data as P (Data, Typeable)-import qualified Data.HashMap.Lazy as HM-import qualified Data.Map as Map-import qualified Data.Maybe as P-import qualified Data.Foldable as P-import qualified Web.FormUrlEncoded as WH-import qualified Web.HttpApiData as WH--import qualified Data.Time as TI-import qualified Data.Time.ISO8601 as TI-import Data.Time (UTCTime)--import Control.Applicative ((<|>))-import Control.Applicative (Alternative)-import Prelude (($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)-import qualified Prelude as P------ * Models----- ** ApiResponse--- |--- An uploaded response--- --- Describes the result of uploading an image resource-data ApiResponse = ApiResponse-  { apiResponseCode :: !(Maybe Int) -- ^ "code"-  , apiResponseType :: !(Maybe Text) -- ^ "type"-  , apiResponseMessage :: !(Maybe Text) -- ^ "message"-  } deriving (P.Show,P.Eq,P.Typeable)--instance A.FromJSON ApiResponse where-  parseJSON = A.withObject "ApiResponse" $ \o ->-    ApiResponse-      <$> (o .:? "code")-      <*> (o .:? "type")-      <*> (o .:? "message")--instance A.ToJSON ApiResponse where-  toJSON ApiResponse {..} =-   _omitNulls-      [ "code" .=  apiResponseCode-      , "type" .=  apiResponseType-      , "message" .=  apiResponseMessage-      ]----- | Construct a value of type 'ApiResponse' (by applying it's required fields, if any)-mkApiResponse-  :: ApiResponse-mkApiResponse =-  ApiResponse-  { apiResponseCode = Nothing-  , apiResponseType = Nothing-  , apiResponseMessage = Nothing-  }-  ----- ** Category--- |--- Pet catehgry--- --- A category for a pet-data Category = Category-  { categoryId :: !(Maybe Integer) -- ^ "id"-  , categoryName :: !(Maybe Text) -- ^ "name"-  } deriving (P.Show,P.Eq,P.Typeable)--instance A.FromJSON Category where-  parseJSON = A.withObject "Category" $ \o ->-    Category-      <$> (o .:? "id")-      <*> (o .:? "name")--instance A.ToJSON Category where-  toJSON Category {..} =-   _omitNulls-      [ "id" .=  categoryId-      , "name" .=  categoryName-      ]----- | Construct a value of type 'Category' (by applying it's required fields, if any)-mkCategory-  :: Category-mkCategory =-  Category-  { categoryId = Nothing-  , categoryName = Nothing-  }-  ----- ** Order--- |--- Pet Order--- --- An order for a pets from the pet store-data Order = Order-  { orderId :: !(Maybe Integer) -- ^ "id"-  , orderPetId :: !(Maybe Integer) -- ^ "petId"-  , orderQuantity :: !(Maybe Int) -- ^ "quantity"-  , orderShipDate :: !(Maybe UTCTime) -- ^ "shipDate"-  , orderStatus :: !(Maybe Text) -- ^ "status" - Order Status-  , orderComplete :: !(Maybe Bool) -- ^ "complete"-  } deriving (P.Show,P.Eq,P.Typeable)--instance A.FromJSON Order where-  parseJSON = A.withObject "Order" $ \o ->-    Order-      <$> (o .:? "id")-      <*> (o .:? "petId")-      <*> (o .:? "quantity")-      <*> (o .:? "shipDate" >>= P.mapM _readDateTime)-      <*> (o .:? "status")-      <*> (o .:? "complete")--instance A.ToJSON Order where-  toJSON Order {..} =-   _omitNulls-      [ "id" .=  orderId-      , "petId" .=  orderPetId-      , "quantity" .=  orderQuantity-      , "shipDate" .= P.fmap _showDateTime orderShipDate-      , "status" .=  orderStatus-      , "complete" .=  orderComplete-      ]----- | Construct a value of type 'Order' (by applying it's required fields, if any)-mkOrder-  :: Order-mkOrder =-  Order-  { orderId = Nothing-  , orderPetId = Nothing-  , orderQuantity = Nothing-  , orderShipDate = Nothing-  , orderStatus = Nothing-  , orderComplete = Nothing-  }-  ----- ** Pet--- |--- a Pet--- --- A pet for sale in the pet store-data Pet = Pet-  { petId :: !(Maybe Integer) -- ^ "id"-  , petCategory :: !(Maybe Category) -- ^ "category"-  , petName :: !(Text) -- ^ /Required/ "name"-  , petPhotoUrls :: !([Text]) -- ^ /Required/ "photoUrls"-  , petTags :: !(Maybe [Tag]) -- ^ "tags"-  , petStatus :: !(Maybe Text) -- ^ "status" - pet status in the store-  } deriving (P.Show,P.Eq,P.Typeable)--instance A.FromJSON Pet where-  parseJSON = A.withObject "Pet" $ \o ->-    Pet-      <$> (o .:? "id")-      <*> (o .:? "category")-      <*> (o .:  "name")-      <*> (o .:  "photoUrls")-      <*> (o .:? "tags")-      <*> (o .:? "status")--instance A.ToJSON Pet where-  toJSON Pet {..} =-   _omitNulls-      [ "id" .=  petId-      , "category" .=  petCategory-      , "name" .=  petName-      , "photoUrls" .=  petPhotoUrls-      , "tags" .=  petTags-      , "status" .=  petStatus-      ]----- | Construct a value of type 'Pet' (by applying it's required fields, if any)-mkPet-  :: Text -- ^ 'petName' -  -> [Text] -- ^ 'petPhotoUrls' -  -> Pet-mkPet petName petPhotoUrls =-  Pet-  { petId = Nothing-  , petCategory = Nothing-  , petName-  , petPhotoUrls-  , petTags = Nothing-  , petStatus = Nothing-  }-  ----- ** Tag--- |--- Pet Tag--- --- A tag for a pet-data Tag = Tag-  { tagId :: !(Maybe Integer) -- ^ "id"-  , tagName :: !(Maybe Text) -- ^ "name"-  } deriving (P.Show,P.Eq,P.Typeable)--instance A.FromJSON Tag where-  parseJSON = A.withObject "Tag" $ \o ->-    Tag-      <$> (o .:? "id")-      <*> (o .:? "name")--instance A.ToJSON Tag where-  toJSON Tag {..} =-   _omitNulls-      [ "id" .=  tagId-      , "name" .=  tagName-      ]----- | Construct a value of type 'Tag' (by applying it's required fields, if any)-mkTag-  :: Tag-mkTag =-  Tag-  { tagId = Nothing-  , tagName = Nothing-  }-  ----- ** User--- |--- a User--- --- A User who is purchasing from the pet store-data User = User-  { userId :: !(Maybe Integer) -- ^ "id"-  , userUsername :: !(Maybe Text) -- ^ "username"-  , userFirstName :: !(Maybe Text) -- ^ "firstName"-  , userLastName :: !(Maybe Text) -- ^ "lastName"-  , userEmail :: !(Maybe Text) -- ^ "email"-  , userPassword :: !(Maybe Text) -- ^ "password"-  , userPhone :: !(Maybe Text) -- ^ "phone"-  , userUserStatus :: !(Maybe Int) -- ^ "userStatus" - User Status-  } deriving (P.Show,P.Eq,P.Typeable)--instance A.FromJSON User where-  parseJSON = A.withObject "User" $ \o ->-    User-      <$> (o .:? "id")-      <*> (o .:? "username")-      <*> (o .:? "firstName")-      <*> (o .:? "lastName")-      <*> (o .:? "email")-      <*> (o .:? "password")-      <*> (o .:? "phone")-      <*> (o .:? "userStatus")--instance A.ToJSON User where-  toJSON User {..} =-   _omitNulls-      [ "id" .=  userId-      , "username" .=  userUsername-      , "firstName" .=  userFirstName-      , "lastName" .=  userLastName-      , "email" .=  userEmail-      , "password" .=  userPassword-      , "phone" .=  userPhone-      , "userStatus" .=  userUserStatus-      ]----- | Construct a value of type 'User' (by applying it's required fields, if any)-mkUser-  :: User-mkUser =-  User-  { userId = Nothing-  , userUsername = Nothing-  , userFirstName = Nothing-  , userLastName = Nothing-  , userEmail = Nothing-  , userPassword = Nothing-  , userPhone = Nothing-  , userUserStatus = Nothing-  }-  ----- * Utils---- | Removes Null fields.  (OpenAPI-Specification 2.0 does not allow Null in JSON)--_omitNulls :: [(Text, A.Value)] -> A.Value-_omitNulls = A.object . P.filter notNull-  where-    notNull (_, A.Null) = False-    notNull _ = True--_toFormItem :: (WH.ToHttpApiData a, Functor f) => t -> f a -> f (t, [Text])-_toFormItem name x = (name,) . (:[]) . WH.toQueryParam <$> x--_emptyToNothing :: Maybe String -> Maybe String-_emptyToNothing (Just "") = Nothing-_emptyToNothing x = x-{-# INLINE _emptyToNothing #-}--_memptyToNothing :: (P.Monoid a, P.Eq a) => Maybe a -> Maybe a-_memptyToNothing (Just x) | x P.== P.mempty = Nothing-_memptyToNothing x = x-{-# INLINE _memptyToNothing #-}---- * DateTime Formatting---- | @_parseISO8601@-_readDateTime :: (TI.ParseTime t, Monad m, Alternative m) => String -> m t-_readDateTime =-  _parseISO8601-{-# INLINE _readDateTime #-}---- | @TI.formatISO8601Millis@-_showDateTime :: (t ~ UTCTime, TI.FormatTime t) => t -> String-_showDateTime =-  TI.formatISO8601Millis-{-# INLINE _showDateTime #-}--_parseISO8601 :: (TI.ParseTime t, Monad m, Alternative m) => String -> m t-_parseISO8601 t =-  P.asum $-  P.flip (TI.parseTimeM True TI.defaultTimeLocale) t <$>-  ["%FT%T%QZ", "%FT%T%Q%z", "%FT%T%Q%Z"]-{-# INLINE _parseISO8601 #-}---- * Date Formatting---- | @TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d"@-_readDate :: (TI.ParseTime t, Monad m) => String -> m t-_readDate =-  TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d"-{-# INLINE _readDate #-}---- | @TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"@-_showDate :: TI.FormatTime t => t -> String-_showDate =-  TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"-{-# INLINE _showDate #-}++import qualified Data.Aeson as A+import qualified Data.ByteString as B+import qualified Data.ByteString.Lazy as BL+import qualified Data.ByteString.Base64.Lazy as BL64+import qualified Data.Data as P (Data, Typeable)+import qualified Data.HashMap.Lazy as HM+import qualified Data.Map as Map+import qualified Data.Set as Set+import qualified Data.Maybe as P+import qualified Data.Foldable as P+import qualified Web.FormUrlEncoded as WH+import qualified Web.HttpApiData as WH+import qualified Control.DeepSeq as NF+import qualified Data.Ix as P+import qualified Data.Text as T+import qualified Data.Text.Encoding as T+import qualified Control.Arrow as P (left)+import Data.Text (Text)++import qualified Data.Time as TI+import qualified Data.Time.ISO8601 as TI++import Control.Applicative ((<|>))+import Control.Applicative (Alternative)+import Prelude (($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)+import qualified Prelude as P++++-- * Models+++-- ** AdditionalPropertiesClass+-- |+data AdditionalPropertiesClass = AdditionalPropertiesClass+  { additionalPropertiesClassMapProperty :: !(Maybe (Map.Map String Text)) -- ^ "map_property"+  , additionalPropertiesClassMapOfMapProperty :: !(Maybe (Map.Map String (Map.Map String Text))) -- ^ "map_of_map_property"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON AdditionalPropertiesClass where+  parseJSON = A.withObject "AdditionalPropertiesClass" $ \o ->+    AdditionalPropertiesClass+      <$> (o .:? "map_property")+      <*> (o .:? "map_of_map_property")++instance A.ToJSON AdditionalPropertiesClass where+  toJSON AdditionalPropertiesClass {..} =+   _omitNulls+      [ "map_property" .= additionalPropertiesClassMapProperty+      , "map_of_map_property" .= additionalPropertiesClassMapOfMapProperty+      ]+++-- | Construct a value of type 'AdditionalPropertiesClass' (by applying it's required fields, if any)+mkAdditionalPropertiesClass+  :: AdditionalPropertiesClass+mkAdditionalPropertiesClass =+  AdditionalPropertiesClass+  { additionalPropertiesClassMapProperty = Nothing+  , additionalPropertiesClassMapOfMapProperty = Nothing+  }+  ++-- ** Animal+-- |+data Animal = Animal+  { animalClassName :: !(Text) -- ^ /Required/ "className"+  , animalColor :: !(Maybe Text) -- ^ "color"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Animal where+  parseJSON = A.withObject "Animal" $ \o ->+    Animal+      <$> (o .:  "className")+      <*> (o .:? "color")++instance A.ToJSON Animal where+  toJSON Animal {..} =+   _omitNulls+      [ "className" .= animalClassName+      , "color" .= animalColor+      ]+++-- | Construct a value of type 'Animal' (by applying it's required fields, if any)+mkAnimal+  :: Text -- ^ 'animalClassName' +  -> Animal+mkAnimal animalClassName =+  Animal+  { animalClassName+  , animalColor = Nothing+  }+  ++-- ** AnimalFarm+-- |+data AnimalFarm = AnimalFarm+  { +  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON AnimalFarm where+  parseJSON = A.withObject "AnimalFarm" $ \o ->+    pure AnimalFarm+      ++instance A.ToJSON AnimalFarm where+  toJSON AnimalFarm  =+   _omitNulls+      [ +      ]+++-- | Construct a value of type 'AnimalFarm' (by applying it's required fields, if any)+mkAnimalFarm+  :: AnimalFarm+mkAnimalFarm =+  AnimalFarm+  { +  }+  ++-- ** ApiResponse+-- |+data ApiResponse = ApiResponse+  { apiResponseCode :: !(Maybe Int) -- ^ "code"+  , apiResponseType :: !(Maybe Text) -- ^ "type"+  , apiResponseMessage :: !(Maybe Text) -- ^ "message"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON ApiResponse where+  parseJSON = A.withObject "ApiResponse" $ \o ->+    ApiResponse+      <$> (o .:? "code")+      <*> (o .:? "type")+      <*> (o .:? "message")++instance A.ToJSON ApiResponse where+  toJSON ApiResponse {..} =+   _omitNulls+      [ "code" .= apiResponseCode+      , "type" .= apiResponseType+      , "message" .= apiResponseMessage+      ]+++-- | Construct a value of type 'ApiResponse' (by applying it's required fields, if any)+mkApiResponse+  :: ApiResponse+mkApiResponse =+  ApiResponse+  { apiResponseCode = Nothing+  , apiResponseType = Nothing+  , apiResponseMessage = Nothing+  }+  ++-- ** ArrayOfArrayOfNumberOnly+-- |+data ArrayOfArrayOfNumberOnly = ArrayOfArrayOfNumberOnly+  { arrayOfArrayOfNumberOnlyArrayArrayNumber :: !(Maybe [[Double]]) -- ^ "ArrayArrayNumber"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON ArrayOfArrayOfNumberOnly where+  parseJSON = A.withObject "ArrayOfArrayOfNumberOnly" $ \o ->+    ArrayOfArrayOfNumberOnly+      <$> (o .:? "ArrayArrayNumber")++instance A.ToJSON ArrayOfArrayOfNumberOnly where+  toJSON ArrayOfArrayOfNumberOnly {..} =+   _omitNulls+      [ "ArrayArrayNumber" .= arrayOfArrayOfNumberOnlyArrayArrayNumber+      ]+++-- | Construct a value of type 'ArrayOfArrayOfNumberOnly' (by applying it's required fields, if any)+mkArrayOfArrayOfNumberOnly+  :: ArrayOfArrayOfNumberOnly+mkArrayOfArrayOfNumberOnly =+  ArrayOfArrayOfNumberOnly+  { arrayOfArrayOfNumberOnlyArrayArrayNumber = Nothing+  }+  ++-- ** ArrayOfNumberOnly+-- |+data ArrayOfNumberOnly = ArrayOfNumberOnly+  { arrayOfNumberOnlyArrayNumber :: !(Maybe [Double]) -- ^ "ArrayNumber"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON ArrayOfNumberOnly where+  parseJSON = A.withObject "ArrayOfNumberOnly" $ \o ->+    ArrayOfNumberOnly+      <$> (o .:? "ArrayNumber")++instance A.ToJSON ArrayOfNumberOnly where+  toJSON ArrayOfNumberOnly {..} =+   _omitNulls+      [ "ArrayNumber" .= arrayOfNumberOnlyArrayNumber+      ]+++-- | Construct a value of type 'ArrayOfNumberOnly' (by applying it's required fields, if any)+mkArrayOfNumberOnly+  :: ArrayOfNumberOnly+mkArrayOfNumberOnly =+  ArrayOfNumberOnly+  { arrayOfNumberOnlyArrayNumber = Nothing+  }+  ++-- ** ArrayTest+-- |+data ArrayTest = ArrayTest+  { arrayTestArrayOfString :: !(Maybe [Text]) -- ^ "array_of_string"+  , arrayTestArrayArrayOfInteger :: !(Maybe [[Integer]]) -- ^ "array_array_of_integer"+  , arrayTestArrayArrayOfModel :: !(Maybe [[ReadOnlyFirst]]) -- ^ "array_array_of_model"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON ArrayTest where+  parseJSON = A.withObject "ArrayTest" $ \o ->+    ArrayTest+      <$> (o .:? "array_of_string")+      <*> (o .:? "array_array_of_integer")+      <*> (o .:? "array_array_of_model")++instance A.ToJSON ArrayTest where+  toJSON ArrayTest {..} =+   _omitNulls+      [ "array_of_string" .= arrayTestArrayOfString+      , "array_array_of_integer" .= arrayTestArrayArrayOfInteger+      , "array_array_of_model" .= arrayTestArrayArrayOfModel+      ]+++-- | Construct a value of type 'ArrayTest' (by applying it's required fields, if any)+mkArrayTest+  :: ArrayTest+mkArrayTest =+  ArrayTest+  { arrayTestArrayOfString = Nothing+  , arrayTestArrayArrayOfInteger = Nothing+  , arrayTestArrayArrayOfModel = Nothing+  }+  ++-- ** Capitalization+-- |+data Capitalization = Capitalization+  { capitalizationSmallCamel :: !(Maybe Text) -- ^ "smallCamel"+  , capitalizationCapitalCamel :: !(Maybe Text) -- ^ "CapitalCamel"+  , capitalizationSmallSnake :: !(Maybe Text) -- ^ "small_Snake"+  , capitalizationCapitalSnake :: !(Maybe Text) -- ^ "Capital_Snake"+  , capitalizationScaEthFlowPoints :: !(Maybe Text) -- ^ "SCA_ETH_Flow_Points"+  , capitalizationAttName :: !(Maybe Text) -- ^ "ATT_NAME" - Name of the pet +  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Capitalization where+  parseJSON = A.withObject "Capitalization" $ \o ->+    Capitalization+      <$> (o .:? "smallCamel")+      <*> (o .:? "CapitalCamel")+      <*> (o .:? "small_Snake")+      <*> (o .:? "Capital_Snake")+      <*> (o .:? "SCA_ETH_Flow_Points")+      <*> (o .:? "ATT_NAME")++instance A.ToJSON Capitalization where+  toJSON Capitalization {..} =+   _omitNulls+      [ "smallCamel" .= capitalizationSmallCamel+      , "CapitalCamel" .= capitalizationCapitalCamel+      , "small_Snake" .= capitalizationSmallSnake+      , "Capital_Snake" .= capitalizationCapitalSnake+      , "SCA_ETH_Flow_Points" .= capitalizationScaEthFlowPoints+      , "ATT_NAME" .= capitalizationAttName+      ]+++-- | Construct a value of type 'Capitalization' (by applying it's required fields, if any)+mkCapitalization+  :: Capitalization+mkCapitalization =+  Capitalization+  { capitalizationSmallCamel = Nothing+  , capitalizationCapitalCamel = Nothing+  , capitalizationSmallSnake = Nothing+  , capitalizationCapitalSnake = Nothing+  , capitalizationScaEthFlowPoints = Nothing+  , capitalizationAttName = Nothing+  }+  ++-- ** Category+-- |+data Category = Category+  { categoryId :: !(Maybe Integer) -- ^ "id"+  , categoryName :: !(Maybe Text) -- ^ "name"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Category where+  parseJSON = A.withObject "Category" $ \o ->+    Category+      <$> (o .:? "id")+      <*> (o .:? "name")++instance A.ToJSON Category where+  toJSON Category {..} =+   _omitNulls+      [ "id" .= categoryId+      , "name" .= categoryName+      ]+++-- | Construct a value of type 'Category' (by applying it's required fields, if any)+mkCategory+  :: Category+mkCategory =+  Category+  { categoryId = Nothing+  , categoryName = Nothing+  }+  ++-- ** ClassModel+-- |+-- Model for testing model with \"_class\" property+data ClassModel = ClassModel+  { classModelClass :: !(Maybe Text) -- ^ "_class"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON ClassModel where+  parseJSON = A.withObject "ClassModel" $ \o ->+    ClassModel+      <$> (o .:? "_class")++instance A.ToJSON ClassModel where+  toJSON ClassModel {..} =+   _omitNulls+      [ "_class" .= classModelClass+      ]+++-- | Construct a value of type 'ClassModel' (by applying it's required fields, if any)+mkClassModel+  :: ClassModel+mkClassModel =+  ClassModel+  { classModelClass = Nothing+  }+  ++-- ** Client+-- |+data Client = Client+  { clientClient :: !(Maybe Text) -- ^ "client"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Client where+  parseJSON = A.withObject "Client" $ \o ->+    Client+      <$> (o .:? "client")++instance A.ToJSON Client where+  toJSON Client {..} =+   _omitNulls+      [ "client" .= clientClient+      ]+++-- | Construct a value of type 'Client' (by applying it's required fields, if any)+mkClient+  :: Client+mkClient =+  Client+  { clientClient = Nothing+  }+  ++-- ** EnumArrays+-- |+data EnumArrays = EnumArrays+  { enumArraysJustSymbol :: !(Maybe Text) -- ^ "just_symbol"+  , enumArraysArrayEnum :: !(Maybe [Text]) -- ^ "array_enum"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON EnumArrays where+  parseJSON = A.withObject "EnumArrays" $ \o ->+    EnumArrays+      <$> (o .:? "just_symbol")+      <*> (o .:? "array_enum")++instance A.ToJSON EnumArrays where+  toJSON EnumArrays {..} =+   _omitNulls+      [ "just_symbol" .= enumArraysJustSymbol+      , "array_enum" .= enumArraysArrayEnum+      ]+++-- | Construct a value of type 'EnumArrays' (by applying it's required fields, if any)+mkEnumArrays+  :: EnumArrays+mkEnumArrays =+  EnumArrays+  { enumArraysJustSymbol = Nothing+  , enumArraysArrayEnum = Nothing+  }+  ++-- ** EnumClass+-- |+data EnumClass = EnumClass+  { +  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON EnumClass where+  parseJSON = A.withObject "EnumClass" $ \o ->+    pure EnumClass+      ++instance A.ToJSON EnumClass where+  toJSON EnumClass  =+   _omitNulls+      [ +      ]+++-- | Construct a value of type 'EnumClass' (by applying it's required fields, if any)+mkEnumClass+  :: EnumClass+mkEnumClass =+  EnumClass+  { +  }+  ++-- ** EnumTest+-- |+data EnumTest = EnumTest+  { enumTestEnumString :: !(Maybe Text) -- ^ "enum_string"+  , enumTestEnumInteger :: !(Maybe Int) -- ^ "enum_integer"+  , enumTestEnumNumber :: !(Maybe Double) -- ^ "enum_number"+  , enumTestOuterEnum :: !(Maybe OuterEnum) -- ^ "outerEnum"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON EnumTest where+  parseJSON = A.withObject "EnumTest" $ \o ->+    EnumTest+      <$> (o .:? "enum_string")+      <*> (o .:? "enum_integer")+      <*> (o .:? "enum_number")+      <*> (o .:? "outerEnum")++instance A.ToJSON EnumTest where+  toJSON EnumTest {..} =+   _omitNulls+      [ "enum_string" .= enumTestEnumString+      , "enum_integer" .= enumTestEnumInteger+      , "enum_number" .= enumTestEnumNumber+      , "outerEnum" .= enumTestOuterEnum+      ]+++-- | Construct a value of type 'EnumTest' (by applying it's required fields, if any)+mkEnumTest+  :: EnumTest+mkEnumTest =+  EnumTest+  { enumTestEnumString = Nothing+  , enumTestEnumInteger = Nothing+  , enumTestEnumNumber = Nothing+  , enumTestOuterEnum = Nothing+  }+  ++-- ** FormatTest+-- |+data FormatTest = FormatTest+  { formatTestInteger :: !(Maybe Int) -- ^ "integer"+  , formatTestInt32 :: !(Maybe Int) -- ^ "int32"+  , formatTestInt64 :: !(Maybe Integer) -- ^ "int64"+  , formatTestNumber :: !(Double) -- ^ /Required/ "number"+  , formatTestFloat :: !(Maybe Float) -- ^ "float"+  , formatTestDouble :: !(Maybe Double) -- ^ "double"+  , formatTestString :: !(Maybe Text) -- ^ "string"+  , formatTestByte :: !(ByteArray) -- ^ /Required/ "byte"+  , formatTestBinary :: !(Maybe Binary) -- ^ "binary"+  , formatTestDate :: !(Date) -- ^ /Required/ "date"+  , formatTestDateTime :: !(Maybe DateTime) -- ^ "dateTime"+  , formatTestUuid :: !(Maybe Text) -- ^ "uuid"+  , formatTestPassword :: !(Text) -- ^ /Required/ "password"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON FormatTest where+  parseJSON = A.withObject "FormatTest" $ \o ->+    FormatTest+      <$> (o .:? "integer")+      <*> (o .:? "int32")+      <*> (o .:? "int64")+      <*> (o .:  "number")+      <*> (o .:? "float")+      <*> (o .:? "double")+      <*> (o .:? "string")+      <*> (o .:  "byte")+      <*> (o .:? "binary")+      <*> (o .:  "date")+      <*> (o .:? "dateTime")+      <*> (o .:? "uuid")+      <*> (o .:  "password")++instance A.ToJSON FormatTest where+  toJSON FormatTest {..} =+   _omitNulls+      [ "integer" .= formatTestInteger+      , "int32" .= formatTestInt32+      , "int64" .= formatTestInt64+      , "number" .= formatTestNumber+      , "float" .= formatTestFloat+      , "double" .= formatTestDouble+      , "string" .= formatTestString+      , "byte" .= formatTestByte+      , "binary" .= formatTestBinary+      , "date" .= formatTestDate+      , "dateTime" .= formatTestDateTime+      , "uuid" .= formatTestUuid+      , "password" .= formatTestPassword+      ]+++-- | 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 formatTestNumber formatTestByte formatTestDate formatTestPassword =+  FormatTest+  { formatTestInteger = Nothing+  , formatTestInt32 = Nothing+  , formatTestInt64 = Nothing+  , formatTestNumber+  , formatTestFloat = Nothing+  , formatTestDouble = Nothing+  , formatTestString = Nothing+  , formatTestByte+  , formatTestBinary = Nothing+  , formatTestDate+  , formatTestDateTime = Nothing+  , formatTestUuid = Nothing+  , formatTestPassword+  }+  ++-- ** HasOnlyReadOnly+-- |+data HasOnlyReadOnly = HasOnlyReadOnly+  { hasOnlyReadOnlyBar :: !(Maybe Text) -- ^ "bar"+  , hasOnlyReadOnlyFoo :: !(Maybe Text) -- ^ "foo"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON HasOnlyReadOnly where+  parseJSON = A.withObject "HasOnlyReadOnly" $ \o ->+    HasOnlyReadOnly+      <$> (o .:? "bar")+      <*> (o .:? "foo")++instance A.ToJSON HasOnlyReadOnly where+  toJSON HasOnlyReadOnly {..} =+   _omitNulls+      [ "bar" .= hasOnlyReadOnlyBar+      , "foo" .= hasOnlyReadOnlyFoo+      ]+++-- | Construct a value of type 'HasOnlyReadOnly' (by applying it's required fields, if any)+mkHasOnlyReadOnly+  :: HasOnlyReadOnly+mkHasOnlyReadOnly =+  HasOnlyReadOnly+  { hasOnlyReadOnlyBar = Nothing+  , hasOnlyReadOnlyFoo = Nothing+  }+  ++-- ** MapTest+-- |+data MapTest = MapTest+  { mapTestMapMapOfString :: !(Maybe (Map.Map String (Map.Map String Text))) -- ^ "map_map_of_string"+  , mapTestMapOfEnumString :: !(Maybe (Map.Map String Text)) -- ^ "map_of_enum_string"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON MapTest where+  parseJSON = A.withObject "MapTest" $ \o ->+    MapTest+      <$> (o .:? "map_map_of_string")+      <*> (o .:? "map_of_enum_string")++instance A.ToJSON MapTest where+  toJSON MapTest {..} =+   _omitNulls+      [ "map_map_of_string" .= mapTestMapMapOfString+      , "map_of_enum_string" .= mapTestMapOfEnumString+      ]+++-- | Construct a value of type 'MapTest' (by applying it's required fields, if any)+mkMapTest+  :: MapTest+mkMapTest =+  MapTest+  { mapTestMapMapOfString = Nothing+  , mapTestMapOfEnumString = Nothing+  }+  ++-- ** MixedPropertiesAndAdditionalPropertiesClass+-- |+data MixedPropertiesAndAdditionalPropertiesClass = MixedPropertiesAndAdditionalPropertiesClass+  { mixedPropertiesAndAdditionalPropertiesClassUuid :: !(Maybe Text) -- ^ "uuid"+  , mixedPropertiesAndAdditionalPropertiesClassDateTime :: !(Maybe DateTime) -- ^ "dateTime"+  , mixedPropertiesAndAdditionalPropertiesClassMap :: !(Maybe (Map.Map String Animal)) -- ^ "map"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON MixedPropertiesAndAdditionalPropertiesClass where+  parseJSON = A.withObject "MixedPropertiesAndAdditionalPropertiesClass" $ \o ->+    MixedPropertiesAndAdditionalPropertiesClass+      <$> (o .:? "uuid")+      <*> (o .:? "dateTime")+      <*> (o .:? "map")++instance A.ToJSON MixedPropertiesAndAdditionalPropertiesClass where+  toJSON MixedPropertiesAndAdditionalPropertiesClass {..} =+   _omitNulls+      [ "uuid" .= mixedPropertiesAndAdditionalPropertiesClassUuid+      , "dateTime" .= mixedPropertiesAndAdditionalPropertiesClassDateTime+      , "map" .= mixedPropertiesAndAdditionalPropertiesClassMap+      ]+++-- | Construct a value of type 'MixedPropertiesAndAdditionalPropertiesClass' (by applying it's required fields, if any)+mkMixedPropertiesAndAdditionalPropertiesClass+  :: MixedPropertiesAndAdditionalPropertiesClass+mkMixedPropertiesAndAdditionalPropertiesClass =+  MixedPropertiesAndAdditionalPropertiesClass+  { mixedPropertiesAndAdditionalPropertiesClassUuid = Nothing+  , mixedPropertiesAndAdditionalPropertiesClassDateTime = Nothing+  , mixedPropertiesAndAdditionalPropertiesClassMap = Nothing+  }+  ++-- ** Model200Response+-- |+-- Model for testing model name starting with number+data Model200Response = Model200Response+  { model200ResponseName :: !(Maybe Int) -- ^ "name"+  , model200ResponseClass :: !(Maybe Text) -- ^ "class"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Model200Response where+  parseJSON = A.withObject "Model200Response" $ \o ->+    Model200Response+      <$> (o .:? "name")+      <*> (o .:? "class")++instance A.ToJSON Model200Response where+  toJSON Model200Response {..} =+   _omitNulls+      [ "name" .= model200ResponseName+      , "class" .= model200ResponseClass+      ]+++-- | Construct a value of type 'Model200Response' (by applying it's required fields, if any)+mkModel200Response+  :: Model200Response+mkModel200Response =+  Model200Response+  { model200ResponseName = Nothing+  , model200ResponseClass = Nothing+  }+  ++-- ** ModelList+-- |+data ModelList = ModelList+  { modelList123List :: !(Maybe Text) -- ^ "123-list"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON ModelList where+  parseJSON = A.withObject "ModelList" $ \o ->+    ModelList+      <$> (o .:? "123-list")++instance A.ToJSON ModelList where+  toJSON ModelList {..} =+   _omitNulls+      [ "123-list" .= modelList123List+      ]+++-- | Construct a value of type 'ModelList' (by applying it's required fields, if any)+mkModelList+  :: ModelList+mkModelList =+  ModelList+  { modelList123List = Nothing+  }+  ++-- ** ModelReturn+-- |+-- Model for testing reserved words+data ModelReturn = ModelReturn+  { modelReturnReturn :: !(Maybe Int) -- ^ "return"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON ModelReturn where+  parseJSON = A.withObject "ModelReturn" $ \o ->+    ModelReturn+      <$> (o .:? "return")++instance A.ToJSON ModelReturn where+  toJSON ModelReturn {..} =+   _omitNulls+      [ "return" .= modelReturnReturn+      ]+++-- | Construct a value of type 'ModelReturn' (by applying it's required fields, if any)+mkModelReturn+  :: ModelReturn+mkModelReturn =+  ModelReturn+  { modelReturnReturn = Nothing+  }+  ++-- ** Name+-- |+-- Model for testing model name same as property name+data Name = Name+  { nameName :: !(Int) -- ^ /Required/ "name"+  , nameSnakeCase :: !(Maybe Int) -- ^ "snake_case"+  , nameProperty :: !(Maybe Text) -- ^ "property"+  , name123Number :: !(Maybe Int) -- ^ "123Number"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Name where+  parseJSON = A.withObject "Name" $ \o ->+    Name+      <$> (o .:  "name")+      <*> (o .:? "snake_case")+      <*> (o .:? "property")+      <*> (o .:? "123Number")++instance A.ToJSON Name where+  toJSON Name {..} =+   _omitNulls+      [ "name" .= nameName+      , "snake_case" .= nameSnakeCase+      , "property" .= nameProperty+      , "123Number" .= name123Number+      ]+++-- | Construct a value of type 'Name' (by applying it's required fields, if any)+mkName+  :: Int -- ^ 'nameName' +  -> Name+mkName nameName =+  Name+  { nameName+  , nameSnakeCase = Nothing+  , nameProperty = Nothing+  , name123Number = Nothing+  }+  ++-- ** NumberOnly+-- |+data NumberOnly = NumberOnly+  { numberOnlyJustNumber :: !(Maybe Double) -- ^ "JustNumber"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON NumberOnly where+  parseJSON = A.withObject "NumberOnly" $ \o ->+    NumberOnly+      <$> (o .:? "JustNumber")++instance A.ToJSON NumberOnly where+  toJSON NumberOnly {..} =+   _omitNulls+      [ "JustNumber" .= numberOnlyJustNumber+      ]+++-- | Construct a value of type 'NumberOnly' (by applying it's required fields, if any)+mkNumberOnly+  :: NumberOnly+mkNumberOnly =+  NumberOnly+  { numberOnlyJustNumber = Nothing+  }+  ++-- ** Order+-- |+data Order = Order+  { orderId :: !(Maybe Integer) -- ^ "id"+  , orderPetId :: !(Maybe Integer) -- ^ "petId"+  , orderQuantity :: !(Maybe Int) -- ^ "quantity"+  , orderShipDate :: !(Maybe DateTime) -- ^ "shipDate"+  , orderStatus :: !(Maybe Text) -- ^ "status" - Order Status+  , orderComplete :: !(Maybe Bool) -- ^ "complete"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Order where+  parseJSON = A.withObject "Order" $ \o ->+    Order+      <$> (o .:? "id")+      <*> (o .:? "petId")+      <*> (o .:? "quantity")+      <*> (o .:? "shipDate")+      <*> (o .:? "status")+      <*> (o .:? "complete")++instance A.ToJSON Order where+  toJSON Order {..} =+   _omitNulls+      [ "id" .= orderId+      , "petId" .= orderPetId+      , "quantity" .= orderQuantity+      , "shipDate" .= orderShipDate+      , "status" .= orderStatus+      , "complete" .= orderComplete+      ]+++-- | Construct a value of type 'Order' (by applying it's required fields, if any)+mkOrder+  :: Order+mkOrder =+  Order+  { orderId = Nothing+  , orderPetId = Nothing+  , orderQuantity = Nothing+  , orderShipDate = Nothing+  , orderStatus = Nothing+  , orderComplete = Nothing+  }+  ++-- ** OuterBoolean+-- |+data OuterBoolean = OuterBoolean+  { +  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON OuterBoolean where+  parseJSON = A.withObject "OuterBoolean" $ \o ->+    pure OuterBoolean+      ++instance A.ToJSON OuterBoolean where+  toJSON OuterBoolean  =+   _omitNulls+      [ +      ]+++-- | Construct a value of type 'OuterBoolean' (by applying it's required fields, if any)+mkOuterBoolean+  :: OuterBoolean+mkOuterBoolean =+  OuterBoolean+  { +  }+  ++-- ** OuterComposite+-- |+data OuterComposite = OuterComposite+  { outerCompositeMyNumber :: !(Maybe OuterNumber) -- ^ "my_number"+  , outerCompositeMyString :: !(Maybe OuterString) -- ^ "my_string"+  , outerCompositeMyBoolean :: !(Maybe OuterBoolean) -- ^ "my_boolean"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON OuterComposite where+  parseJSON = A.withObject "OuterComposite" $ \o ->+    OuterComposite+      <$> (o .:? "my_number")+      <*> (o .:? "my_string")+      <*> (o .:? "my_boolean")++instance A.ToJSON OuterComposite where+  toJSON OuterComposite {..} =+   _omitNulls+      [ "my_number" .= outerCompositeMyNumber+      , "my_string" .= outerCompositeMyString+      , "my_boolean" .= outerCompositeMyBoolean+      ]+++-- | Construct a value of type 'OuterComposite' (by applying it's required fields, if any)+mkOuterComposite+  :: OuterComposite+mkOuterComposite =+  OuterComposite+  { outerCompositeMyNumber = Nothing+  , outerCompositeMyString = Nothing+  , outerCompositeMyBoolean = Nothing+  }+  ++-- ** OuterEnum+-- |+data OuterEnum = OuterEnum+  { +  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON OuterEnum where+  parseJSON = A.withObject "OuterEnum" $ \o ->+    pure OuterEnum+      ++instance A.ToJSON OuterEnum where+  toJSON OuterEnum  =+   _omitNulls+      [ +      ]+++-- | Construct a value of type 'OuterEnum' (by applying it's required fields, if any)+mkOuterEnum+  :: OuterEnum+mkOuterEnum =+  OuterEnum+  { +  }+  ++-- ** OuterNumber+-- |+data OuterNumber = OuterNumber+  { +  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON OuterNumber where+  parseJSON = A.withObject "OuterNumber" $ \o ->+    pure OuterNumber+      ++instance A.ToJSON OuterNumber where+  toJSON OuterNumber  =+   _omitNulls+      [ +      ]+++-- | Construct a value of type 'OuterNumber' (by applying it's required fields, if any)+mkOuterNumber+  :: OuterNumber+mkOuterNumber =+  OuterNumber+  { +  }+  ++-- ** OuterString+-- |+data OuterString = OuterString+  { +  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON OuterString where+  parseJSON = A.withObject "OuterString" $ \o ->+    pure OuterString+      ++instance A.ToJSON OuterString where+  toJSON OuterString  =+   _omitNulls+      [ +      ]+++-- | Construct a value of type 'OuterString' (by applying it's required fields, if any)+mkOuterString+  :: OuterString+mkOuterString =+  OuterString+  { +  }+  ++-- ** Pet+-- |+data Pet = Pet+  { petId :: !(Maybe Integer) -- ^ "id"+  , petCategory :: !(Maybe Category) -- ^ "category"+  , petName :: !(Text) -- ^ /Required/ "name"+  , petPhotoUrls :: !([Text]) -- ^ /Required/ "photoUrls"+  , petTags :: !(Maybe [Tag]) -- ^ "tags"+  , petStatus :: !(Maybe Text) -- ^ "status" - pet status in the store+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Pet where+  parseJSON = A.withObject "Pet" $ \o ->+    Pet+      <$> (o .:? "id")+      <*> (o .:? "category")+      <*> (o .:  "name")+      <*> (o .:  "photoUrls")+      <*> (o .:? "tags")+      <*> (o .:? "status")++instance A.ToJSON Pet where+  toJSON Pet {..} =+   _omitNulls+      [ "id" .= petId+      , "category" .= petCategory+      , "name" .= petName+      , "photoUrls" .= petPhotoUrls+      , "tags" .= petTags+      , "status" .= petStatus+      ]+++-- | Construct a value of type 'Pet' (by applying it's required fields, if any)+mkPet+  :: Text -- ^ 'petName' +  -> [Text] -- ^ 'petPhotoUrls' +  -> Pet+mkPet petName petPhotoUrls =+  Pet+  { petId = Nothing+  , petCategory = Nothing+  , petName+  , petPhotoUrls+  , petTags = Nothing+  , petStatus = Nothing+  }+  ++-- ** ReadOnlyFirst+-- |+data ReadOnlyFirst = ReadOnlyFirst+  { readOnlyFirstBar :: !(Maybe Text) -- ^ "bar"+  , readOnlyFirstBaz :: !(Maybe Text) -- ^ "baz"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON ReadOnlyFirst where+  parseJSON = A.withObject "ReadOnlyFirst" $ \o ->+    ReadOnlyFirst+      <$> (o .:? "bar")+      <*> (o .:? "baz")++instance A.ToJSON ReadOnlyFirst where+  toJSON ReadOnlyFirst {..} =+   _omitNulls+      [ "bar" .= readOnlyFirstBar+      , "baz" .= readOnlyFirstBaz+      ]+++-- | Construct a value of type 'ReadOnlyFirst' (by applying it's required fields, if any)+mkReadOnlyFirst+  :: ReadOnlyFirst+mkReadOnlyFirst =+  ReadOnlyFirst+  { readOnlyFirstBar = Nothing+  , readOnlyFirstBaz = Nothing+  }+  ++-- ** SpecialModelName+-- |+data SpecialModelName = SpecialModelName+  { specialModelNameSpecialPropertyName :: !(Maybe Integer) -- ^ "$special[property.name]"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON SpecialModelName where+  parseJSON = A.withObject "SpecialModelName" $ \o ->+    SpecialModelName+      <$> (o .:? "$special[property.name]")++instance A.ToJSON SpecialModelName where+  toJSON SpecialModelName {..} =+   _omitNulls+      [ "$special[property.name]" .= specialModelNameSpecialPropertyName+      ]+++-- | Construct a value of type 'SpecialModelName' (by applying it's required fields, if any)+mkSpecialModelName+  :: SpecialModelName+mkSpecialModelName =+  SpecialModelName+  { specialModelNameSpecialPropertyName = Nothing+  }+  ++-- ** Tag+-- |+data Tag = Tag+  { tagId :: !(Maybe Integer) -- ^ "id"+  , tagName :: !(Maybe Text) -- ^ "name"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Tag where+  parseJSON = A.withObject "Tag" $ \o ->+    Tag+      <$> (o .:? "id")+      <*> (o .:? "name")++instance A.ToJSON Tag where+  toJSON Tag {..} =+   _omitNulls+      [ "id" .= tagId+      , "name" .= tagName+      ]+++-- | Construct a value of type 'Tag' (by applying it's required fields, if any)+mkTag+  :: Tag+mkTag =+  Tag+  { tagId = Nothing+  , tagName = Nothing+  }+  ++-- ** User+-- |+data User = User+  { userId :: !(Maybe Integer) -- ^ "id"+  , userUsername :: !(Maybe Text) -- ^ "username"+  , userFirstName :: !(Maybe Text) -- ^ "firstName"+  , userLastName :: !(Maybe Text) -- ^ "lastName"+  , userEmail :: !(Maybe Text) -- ^ "email"+  , userPassword :: !(Maybe Text) -- ^ "password"+  , userPhone :: !(Maybe Text) -- ^ "phone"+  , userUserStatus :: !(Maybe Int) -- ^ "userStatus" - User Status+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON User where+  parseJSON = A.withObject "User" $ \o ->+    User+      <$> (o .:? "id")+      <*> (o .:? "username")+      <*> (o .:? "firstName")+      <*> (o .:? "lastName")+      <*> (o .:? "email")+      <*> (o .:? "password")+      <*> (o .:? "phone")+      <*> (o .:? "userStatus")++instance A.ToJSON User where+  toJSON User {..} =+   _omitNulls+      [ "id" .= userId+      , "username" .= userUsername+      , "firstName" .= userFirstName+      , "lastName" .= userLastName+      , "email" .= userEmail+      , "password" .= userPassword+      , "phone" .= userPhone+      , "userStatus" .= userUserStatus+      ]+++-- | Construct a value of type 'User' (by applying it's required fields, if any)+mkUser+  :: User+mkUser =+  User+  { userId = Nothing+  , userUsername = Nothing+  , userFirstName = Nothing+  , userLastName = Nothing+  , userEmail = Nothing+  , userPassword = Nothing+  , userPhone = Nothing+  , userUserStatus = Nothing+  }+  ++-- ** Cat+-- |+data Cat = Cat+  { catClassName :: !(Text) -- ^ /Required/ "className"+  , catColor :: !(Maybe Text) -- ^ "color"+  , catDeclawed :: !(Maybe Bool) -- ^ "declawed"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Cat where+  parseJSON = A.withObject "Cat" $ \o ->+    Cat+      <$> (o .:  "className")+      <*> (o .:? "color")+      <*> (o .:? "declawed")++instance A.ToJSON Cat where+  toJSON Cat {..} =+   _omitNulls+      [ "className" .= catClassName+      , "color" .= catColor+      , "declawed" .= catDeclawed+      ]+++-- | Construct a value of type 'Cat' (by applying it's required fields, if any)+mkCat+  :: Text -- ^ 'catClassName' +  -> Cat+mkCat catClassName =+  Cat+  { catClassName+  , catColor = Nothing+  , catDeclawed = Nothing+  }+  ++-- ** Dog+-- |+data Dog = Dog+  { dogClassName :: !(Text) -- ^ /Required/ "className"+  , dogColor :: !(Maybe Text) -- ^ "color"+  , dogBreed :: !(Maybe Text) -- ^ "breed"+  } deriving (P.Show,P.Eq,P.Typeable)++instance A.FromJSON Dog where+  parseJSON = A.withObject "Dog" $ \o ->+    Dog+      <$> (o .:  "className")+      <*> (o .:? "color")+      <*> (o .:? "breed")++instance A.ToJSON Dog where+  toJSON Dog {..} =+   _omitNulls+      [ "className" .= dogClassName+      , "color" .= dogColor+      , "breed" .= dogBreed+      ]+++-- | Construct a value of type 'Dog' (by applying it's required fields, if any)+mkDog+  :: Text -- ^ 'dogClassName' +  -> Dog+mkDog dogClassName =+  Dog+  { dogClassName+  , dogColor = Nothing+  , dogBreed = Nothing+  }+  ++-- * Utils++-- | Removes Null fields.  (OpenAPI-Specification 2.0 does not allow Null in JSON)++_omitNulls :: [(Text, A.Value)] -> A.Value+_omitNulls = A.object . P.filter notNull+  where+    notNull (_, A.Null) = False+    notNull _ = True++_toFormItem :: (WH.ToHttpApiData a, Functor f) => t -> f a -> f (t, [Text])+_toFormItem name x = (name,) . (:[]) . WH.toQueryParam <$> x++_emptyToNothing :: Maybe String -> Maybe String+_emptyToNothing (Just "") = Nothing+_emptyToNothing x = x+{-# INLINE _emptyToNothing #-}++_memptyToNothing :: (P.Monoid a, P.Eq a) => Maybe a -> Maybe a+_memptyToNothing (Just x) | x P.== P.mempty = Nothing+_memptyToNothing x = x+{-# INLINE _memptyToNothing #-}++-- * DateTime Formatting++newtype DateTime = DateTime { unDateTime :: TI.UTCTime }+  deriving (P.Eq,P.Data,P.Ord,P.Typeable,NF.NFData,TI.ParseTime,TI.FormatTime)+instance A.FromJSON DateTime where+  parseJSON = A.withText "DateTime" (_readDateTime . T.unpack)+instance A.ToJSON DateTime where+  toJSON (DateTime t) = A.toJSON (_showDateTime t)+instance WH.FromHttpApiData DateTime where+  parseUrlPiece = P.left T.pack . _readDateTime . T.unpack+instance WH.ToHttpApiData DateTime where+  toUrlPiece (DateTime t) = T.pack (_showDateTime t)+instance P.Show DateTime where+  show (DateTime t) = _showDateTime t++-- | @_parseISO8601@+_readDateTime :: (TI.ParseTime t, Monad m, Alternative m) => String -> m t+_readDateTime =+  _parseISO8601+{-# INLINE _readDateTime #-}++-- | @TI.formatISO8601Millis@+_showDateTime :: (t ~ TI.UTCTime, TI.FormatTime t) => t -> String+_showDateTime =+  TI.formatISO8601Millis+{-# INLINE _showDateTime #-}++_parseISO8601 :: (TI.ParseTime t, Monad m, Alternative m) => String -> m t+_parseISO8601 t =+  P.asum $+  P.flip (TI.parseTimeM True TI.defaultTimeLocale) t <$>+  ["%FT%T%QZ", "%FT%T%Q%z", "%FT%T%Q%Z"]+{-# INLINE _parseISO8601 #-}++-- * Date Formatting++newtype Date = Date { unDate :: TI.Day }+  deriving (P.Enum,P.Eq,P.Data,P.Ord,P.Ix,NF.NFData,TI.ParseTime,TI.FormatTime)+instance A.FromJSON Date where+  parseJSON = A.withText "Date" (_readDate . T.unpack)+instance A.ToJSON Date where+  toJSON (Date t) = A.toJSON (_showDate t)+instance WH.FromHttpApiData Date where+  parseUrlPiece = P.left T.pack . _readDate . T.unpack+instance WH.ToHttpApiData Date where+  toUrlPiece (Date t) = T.pack (_showDate t)+instance P.Show Date where+  show (Date t) = _showDate t++-- | @TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d"@+_readDate :: (TI.ParseTime t, Monad m) => String -> m t+_readDate =+  TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d"+{-# INLINE _readDate #-}++-- | @TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"@+_showDate :: TI.FormatTime t => t -> String+_showDate =+  TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"+{-# INLINE _showDate #-}++-- * Byte/Binary Formatting++  +-- | base64 encoded characters+newtype ByteArray = ByteArray { unByteArray :: BL.ByteString }+  deriving (P.Eq,P.Data,P.Ord,P.Typeable,NF.NFData)++instance A.FromJSON ByteArray where+  parseJSON = A.withText "ByteArray" _readByteArray+instance A.ToJSON ByteArray where+  toJSON = A.toJSON . _showByteArray+instance WH.FromHttpApiData ByteArray where+  parseUrlPiece = P.left T.pack . _readByteArray+instance WH.ToHttpApiData ByteArray where+  toUrlPiece = _showByteArray+instance P.Show ByteArray where+  show = T.unpack . _showByteArray++-- | read base64 encoded characters+_readByteArray :: Monad m => Text -> m ByteArray+_readByteArray = P.either P.fail (pure . ByteArray) . BL64.decode . BL.fromStrict . T.encodeUtf8+{-# INLINE _readByteArray #-}++-- | show base64 encoded characters+_showByteArray :: ByteArray -> Text+_showByteArray = T.decodeUtf8 . BL.toStrict . BL64.encode . unByteArray+{-# INLINE _showByteArray #-}++-- | any sequence of octets+newtype Binary = Binary { unBinary :: BL.ByteString }+  deriving (P.Eq,P.Data,P.Ord,P.Typeable,NF.NFData)++instance A.FromJSON Binary where+  parseJSON = A.withText "Binary" _readBinaryBase64+instance A.ToJSON Binary where+  toJSON = A.toJSON . _showBinaryBase64+instance WH.FromHttpApiData Binary where+  parseUrlPiece = P.left T.pack . _readBinaryBase64+instance WH.ToHttpApiData Binary where+  toUrlPiece = _showBinaryBase64+instance P.Show Binary where+  show = T.unpack . _showBinaryBase64++_readBinaryBase64 :: Monad m => Text -> m Binary+_readBinaryBase64 = P.either P.fail (pure . Binary) . BL64.decode . BL.fromStrict . T.encodeUtf8+{-# INLINE _readBinaryBase64 #-}++_showBinaryBase64 :: Binary -> Text+_showBinaryBase64 = T.decodeUtf8 . BL.toStrict . BL64.encode . unBinary+{-# INLINE _showBinaryBase64 #-}

@@ -3,26 +3,27 @@ -- see: https://github.com/sol/hpack  name:           swagger-petstore-version:        0.0.1.1+version:        0.0.1.2 synopsis:       Auto-generated swagger-petstore API Client description:    .                 Client library for calling the swagger-petstore API based on http-client.-                host: petstore.swagger.io                 .-                base path: http://petstore.swagger.io/v2+                host: petstore.swagger.io:80                 .+                base path: http://petstore.swagger.io:80/v2+                .                 apiVersion: 0.0.1                 .                 swagger version: 2.0                 .-                OpenAPI-Specification: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md +                OpenAPI-Specification: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md+                . category:       Web homepage:       https://github.com/swagger-api/swagger-codegen#readme-author:         Jon Schoning-maintainer:     jonschoning@gmail.com-copyright:      Copyright (c) 2015 Jon Schoning+author:         Author Name Here+maintainer:     author.name@email.com+copyright:      YEAR - AUTHOR license:        MIT-license-file:   LICENSE build-type:     Simple cabal-version:  >= 1.10 @@ -41,6 +42,7 @@     , unordered-containers     , aeson >=1.0 && <2.0     , bytestring >=0.10.0 && <0.11+    , base64-bytestring >1.0 && <2.0     , containers >=0.5.0.0 && <0.6     , http-types >=0.8 && <0.10     , http-client >=0.5 && <0.6@@ -54,10 +56,11 @@     , network >=2.6.2 && <2.7     , random >=1.1     , exceptions >= 0.4-    , monad-logger >=0.3 && <0.4+    , katip >=0.4 && < 0.6     , safe-exceptions <0.2     , case-insensitive     , microlens >= 0.4.3 && <0.5+    , deepseq >= 1.4 && <1.6   exposed-modules:       SwaggerPetstore       SwaggerPetstore.API@@ -65,6 +68,7 @@       SwaggerPetstore.Model       SwaggerPetstore.MimeTypes       SwaggerPetstore.Lens+      SwaggerPetstore.Logging   other-modules:       Paths_swagger_petstore   default-language: Haskell2010

@@ -1,7 +1,7 @@ {   "swagger" : "2.0",   "info" : {-    "description" : "This is a sample server Petstore server.  You can find out more about Swagger at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/).  For this sample, you can use the api key `special-key` to test the authorization filters.",+    "description" : "This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\",     "version" : "1.0.0",     "title" : "Swagger Petstore",     "termsOfService" : "http://swagger.io/terms/",@@ -13,7 +13,7 @@       "url" : "http://www.apache.org/licenses/LICENSE-2.0.html"     }   },-  "host" : "petstore.swagger.io",+  "host" : "petstore.swagger.io:80",   "basePath" : "/v2",   "tags" : [ {     "name" : "pet",@@ -363,7 +363,7 @@         }       }     },-    "/store/order/{orderId}" : {+    "/store/order/{order_id}" : {       "get" : {         "tags" : [ "store" ],         "summary" : "Find purchase order by ID",@@ -371,7 +371,7 @@         "operationId" : "getOrderById",         "produces" : [ "application/xml", "application/json" ],         "parameters" : [ {-          "name" : "orderId",+          "name" : "order_id",           "in" : "path",           "description" : "ID of pet that needs to be fetched",           "required" : true,@@ -402,7 +402,7 @@         "operationId" : "deleteOrder",         "produces" : [ "application/xml", "application/json" ],         "parameters" : [ {-          "name" : "orderId",+          "name" : "order_id",           "in" : "path",           "description" : "ID of the order that needs to be deleted",           "required" : true,@@ -634,6 +634,428 @@           }         }       }+    },+    "/fake_classname_test" : {+      "patch" : {+        "tags" : [ "fake_classname_tags 123#$%^" ],+        "summary" : "To test class name in snake case",+        "operationId" : "testClassname",+        "consumes" : [ "application/json" ],+        "produces" : [ "application/json" ],+        "parameters" : [ {+          "in" : "body",+          "name" : "body",+          "description" : "client model",+          "required" : true,+          "schema" : {+            "$ref" : "#/definitions/Client"+          }+        } ],+        "responses" : {+          "200" : {+            "description" : "successful operation",+            "schema" : {+              "$ref" : "#/definitions/Client"+            }+          }+        },+        "security" : [ {+          "api_key_query" : [ ]+        } ]+      }+    },+    "/fake" : {+      "get" : {+        "tags" : [ "fake" ],+        "summary" : "To test enum parameters",+        "description" : "To test enum parameters",+        "operationId" : "testEnumParameters",+        "consumes" : [ "*/*" ],+        "produces" : [ "*/*" ],+        "parameters" : [ {+          "name" : "enum_form_string_array",+          "in" : "formData",+          "description" : "Form parameter enum test (string array)",+          "required" : false,+          "type" : "array",+          "items" : {+            "type" : "string",+            "enum" : [ ">", "$" ],+            "default" : "$"+          }+        }, {+          "name" : "enum_form_string",+          "in" : "formData",+          "description" : "Form parameter enum test (string)",+          "required" : false,+          "type" : "string",+          "default" : "-efg",+          "enum" : [ "_abc", "-efg", "(xyz)" ]+        }, {+          "name" : "enum_header_string_array",+          "in" : "header",+          "description" : "Header parameter enum test (string array)",+          "required" : false,+          "type" : "array",+          "items" : {+            "type" : "string",+            "enum" : [ ">", "$" ],+            "default" : "$"+          }+        }, {+          "name" : "enum_header_string",+          "in" : "header",+          "description" : "Header parameter enum test (string)",+          "required" : false,+          "type" : "string",+          "default" : "-efg",+          "enum" : [ "_abc", "-efg", "(xyz)" ]+        }, {+          "name" : "enum_query_string_array",+          "in" : "query",+          "description" : "Query parameter enum test (string array)",+          "required" : false,+          "type" : "array",+          "items" : {+            "type" : "string",+            "enum" : [ ">", "$" ],+            "default" : "$"+          }+        }, {+          "name" : "enum_query_string",+          "in" : "query",+          "description" : "Query parameter enum test (string)",+          "required" : false,+          "type" : "string",+          "default" : "-efg",+          "enum" : [ "_abc", "-efg", "(xyz)" ]+        }, {+          "name" : "enum_query_integer",+          "in" : "query",+          "description" : "Query parameter enum test (double)",+          "required" : false,+          "type" : "integer",+          "format" : "int32",+          "enum" : [ 1, -2 ]+        }, {+          "name" : "enum_query_double",+          "in" : "formData",+          "description" : "Query parameter enum test (double)",+          "required" : false,+          "type" : "number",+          "format" : "double",+          "enum" : [ 1.1, -1.2 ]+        } ],+        "responses" : {+          "400" : {+            "description" : "Invalid request"+          },+          "404" : {+            "description" : "Not found"+          }+        }+      },+      "post" : {+        "tags" : [ "fake" ],+        "summary" : "Fake endpoint for testing various parameters\n假端點\n偽のエンドポイント\n가짜 엔드 포인트\n",+        "description" : "Fake endpoint for testing various parameters\n假端點\n偽のエンドポイント\n가짜 엔드 포인트\n",+        "operationId" : "testEndpointParameters",+        "consumes" : [ "application/xml; charset=utf-8", "application/json; charset=utf-8" ],+        "produces" : [ "application/xml; charset=utf-8", "application/json; charset=utf-8" ],+        "parameters" : [ {+          "name" : "integer",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "integer",+          "maximum" : 100,+          "minimum" : 10+        }, {+          "name" : "int32",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "integer",+          "maximum" : 200,+          "minimum" : 20,+          "format" : "int32"+        }, {+          "name" : "int64",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "integer",+          "format" : "int64"+        }, {+          "name" : "number",+          "in" : "formData",+          "description" : "None",+          "required" : true,+          "type" : "number",+          "maximum" : 543.2,+          "minimum" : 32.1+        }, {+          "name" : "float",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "number",+          "maximum" : 987.6,+          "format" : "float"+        }, {+          "name" : "double",+          "in" : "formData",+          "description" : "None",+          "required" : true,+          "type" : "number",+          "maximum" : 123.4,+          "minimum" : 67.8,+          "format" : "double"+        }, {+          "name" : "string",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "string",+          "pattern" : "/[a-z]/i"+        }, {+          "name" : "pattern_without_delimiter",+          "in" : "formData",+          "description" : "None",+          "required" : true,+          "type" : "string",+          "pattern" : "^[A-Z].*"+        }, {+          "name" : "byte",+          "in" : "formData",+          "description" : "None",+          "required" : true,+          "type" : "string",+          "format" : "byte"+        }, {+          "name" : "binary",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "string",+          "format" : "binary"+        }, {+          "name" : "date",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "string",+          "format" : "date"+        }, {+          "name" : "dateTime",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "string",+          "format" : "date-time"+        }, {+          "name" : "password",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "string",+          "maxLength" : 64,+          "minLength" : 10,+          "format" : "password"+        }, {+          "name" : "callback",+          "in" : "formData",+          "description" : "None",+          "required" : false,+          "type" : "string"+        } ],+        "responses" : {+          "400" : {+            "description" : "Invalid username supplied"+          },+          "404" : {+            "description" : "User not found"+          }+        },+        "security" : [ {+          "http_basic_test" : [ ]+        } ]+      },+      "patch" : {+        "tags" : [ "fake" ],+        "summary" : "To test \"client\" model",+        "description" : "To test \"client\" model",+        "operationId" : "testClientModel",+        "consumes" : [ "application/json" ],+        "produces" : [ "application/json" ],+        "parameters" : [ {+          "in" : "body",+          "name" : "body",+          "description" : "client model",+          "required" : true,+          "schema" : {+            "$ref" : "#/definitions/Client"+          }+        } ],+        "responses" : {+          "200" : {+            "description" : "successful operation",+            "schema" : {+              "$ref" : "#/definitions/Client"+            }+          }+        }+      }+    },+    "/fake/outer/number" : {+      "post" : {+        "tags" : [ "fake" ],+        "description" : "Test serialization of outer number types",+        "operationId" : "fakeOuterNumberSerialize",+        "parameters" : [ {+          "in" : "body",+          "name" : "body",+          "description" : "Input number as post body",+          "required" : false,+          "schema" : {+            "$ref" : "#/definitions/OuterNumber"+          }+        } ],+        "responses" : {+          "200" : {+            "description" : "Output number",+            "schema" : {+              "$ref" : "#/definitions/OuterNumber"+            }+          }+        }+      }+    },+    "/fake/outer/string" : {+      "post" : {+        "tags" : [ "fake" ],+        "description" : "Test serialization of outer string types",+        "operationId" : "fakeOuterStringSerialize",+        "parameters" : [ {+          "in" : "body",+          "name" : "body",+          "description" : "Input string as post body",+          "required" : false,+          "schema" : {+            "$ref" : "#/definitions/OuterString"+          }+        } ],+        "responses" : {+          "200" : {+            "description" : "Output string",+            "schema" : {+              "$ref" : "#/definitions/OuterString"+            }+          }+        }+      }+    },+    "/fake/outer/boolean" : {+      "post" : {+        "tags" : [ "fake" ],+        "description" : "Test serialization of outer boolean types",+        "operationId" : "fakeOuterBooleanSerialize",+        "parameters" : [ {+          "in" : "body",+          "name" : "body",+          "description" : "Input boolean as post body",+          "required" : false,+          "schema" : {+            "$ref" : "#/definitions/OuterBoolean"+          }+        } ],+        "responses" : {+          "200" : {+            "description" : "Output boolean",+            "schema" : {+              "$ref" : "#/definitions/OuterBoolean"+            }+          }+        }+      }+    },+    "/fake/outer/composite" : {+      "post" : {+        "tags" : [ "fake" ],+        "description" : "Test serialization of object with outer number type",+        "operationId" : "fakeOuterCompositeSerialize",+        "parameters" : [ {+          "in" : "body",+          "name" : "body",+          "description" : "Input composite as post body",+          "required" : false,+          "schema" : {+            "$ref" : "#/definitions/OuterComposite"+          }+        } ],+        "responses" : {+          "200" : {+            "description" : "Output composite",+            "schema" : {+              "$ref" : "#/definitions/OuterComposite"+            }+          }+        }+      }+    },+    "/fake/jsonFormData" : {+      "get" : {+        "tags" : [ "fake" ],+        "summary" : "test json serialization of form data",+        "description" : "",+        "operationId" : "testJsonFormData",+        "consumes" : [ "application/json" ],+        "parameters" : [ {+          "name" : "param",+          "in" : "formData",+          "description" : "field1",+          "required" : true,+          "type" : "string"+        }, {+          "name" : "param2",+          "in" : "formData",+          "description" : "field2",+          "required" : true,+          "type" : "string"+        } ],+        "responses" : {+          "200" : {+            "description" : "successful operation"+          }+        }+      }+    },+    "/another-fake/dummy" : {+      "patch" : {+        "tags" : [ "$another-fake?" ],+        "summary" : "To test special tags",+        "description" : "To test special tags",+        "operationId" : "test_special_tags",+        "consumes" : [ "application/json" ],+        "produces" : [ "application/json" ],+        "parameters" : [ {+          "in" : "body",+          "name" : "body",+          "description" : "client model",+          "required" : true,+          "schema" : {+            "$ref" : "#/definitions/Client"+          }+        } ],+        "responses" : {+          "200" : {+            "description" : "successful operation",+            "schema" : {+              "$ref" : "#/definitions/Client"+            }+          }+        }+      }     }   },   "securityDefinitions" : {@@ -650,6 +1072,14 @@       "type" : "apiKey",       "name" : "api_key",       "in" : "header"+    },+    "api_key_query" : {+      "type" : "apiKey",+      "name" : "api_key_query",+      "in" : "query"+    },+    "http_basic_test" : {+      "type" : "basic"     }   },   "definitions" : {@@ -682,8 +1112,6 @@           "default" : false         }       },-      "title" : "Pet Order",-      "description" : "An order for a pets from the pet store",       "xml" : {         "name" : "Order"       }@@ -699,8 +1127,6 @@           "type" : "string"         }       },-      "title" : "Pet catehgry",-      "description" : "A category for a pet",       "xml" : {         "name" : "Category"       }@@ -710,7 +1136,8 @@       "properties" : {         "id" : {           "type" : "integer",-          "format" : "int64"+          "format" : "int64",+          "x-is-unique" : true         },         "username" : {           "type" : "string"@@ -736,8 +1163,6 @@           "description" : "User Status"         }       },-      "title" : "a User",-      "description" : "A User who is purchasing from the pet store",       "xml" : {         "name" : "User"       }@@ -753,8 +1178,6 @@           "type" : "string"         }       },-      "title" : "Pet Tag",-      "description" : "A tag for a pet",       "xml" : {         "name" : "Tag"       }@@ -765,7 +1188,8 @@       "properties" : {         "id" : {           "type" : "integer",-          "format" : "int64"+          "format" : "int64",+          "x-is-unique" : true         },         "category" : {           "$ref" : "#/definitions/Category"@@ -800,8 +1224,6 @@           "enum" : [ "available", "pending", "sold" ]         }       },-      "title" : "a Pet",-      "description" : "A pet for sale in the pet store",       "xml" : {         "name" : "Pet"       }@@ -819,9 +1241,449 @@         "message" : {           "type" : "string"         }+      }+    },+    "$special[model.name]" : {+      "properties" : {+        "$special[property.name]" : {+          "type" : "integer",+          "format" : "int64"+        }       },-      "title" : "An uploaded response",-      "description" : "Describes the result of uploading an image resource"+      "xml" : {+        "name" : "$special[model.name]"+      }+    },+    "Return" : {+      "properties" : {+        "return" : {+          "type" : "integer",+          "format" : "int32"+        }+      },+      "description" : "Model for testing reserved words",+      "xml" : {+        "name" : "Return"+      }+    },+    "Name" : {+      "required" : [ "name" ],+      "properties" : {+        "name" : {+          "type" : "integer",+          "format" : "int32"+        },+        "snake_case" : {+          "type" : "integer",+          "format" : "int32",+          "readOnly" : true+        },+        "property" : {+          "type" : "string"+        },+        "123Number" : {+          "type" : "integer",+          "readOnly" : true+        }+      },+      "description" : "Model for testing model name same as property name",+      "xml" : {+        "name" : "Name"+      }+    },+    "200_response" : {+      "properties" : {+        "name" : {+          "type" : "integer",+          "format" : "int32"+        },+        "class" : {+          "type" : "string"+        }+      },+      "description" : "Model for testing model name starting with number",+      "xml" : {+        "name" : "Name"+      }+    },+    "ClassModel" : {+      "properties" : {+        "_class" : {+          "type" : "string"+        }+      },+      "description" : "Model for testing model with \"_class\" property"+    },+    "Dog" : {+      "allOf" : [ {+        "$ref" : "#/definitions/Animal"+      }, {+        "type" : "object",+        "properties" : {+          "breed" : {+            "type" : "string"+          }+        }+      } ]+    },+    "Cat" : {+      "allOf" : [ {+        "$ref" : "#/definitions/Animal"+      }, {+        "type" : "object",+        "properties" : {+          "declawed" : {+            "type" : "boolean"+          }+        }+      } ]+    },+    "Animal" : {+      "type" : "object",+      "required" : [ "className" ],+      "discriminator" : "className",+      "properties" : {+        "className" : {+          "type" : "string"+        },+        "color" : {+          "type" : "string",+          "default" : "red"+        }+      }+    },+    "AnimalFarm" : {+      "type" : "array",+      "items" : {+        "$ref" : "#/definitions/Animal"+      }+    },+    "format_test" : {+      "type" : "object",+      "required" : [ "byte", "date", "number", "password" ],+      "properties" : {+        "integer" : {+          "type" : "integer",+          "minimum" : 10,+          "maximum" : 100+        },+        "int32" : {+          "type" : "integer",+          "format" : "int32",+          "minimum" : 20,+          "maximum" : 200+        },+        "int64" : {+          "type" : "integer",+          "format" : "int64"+        },+        "number" : {+          "type" : "number",+          "minimum" : 32.1,+          "maximum" : 543.2+        },+        "float" : {+          "type" : "number",+          "format" : "float",+          "minimum" : 54.3,+          "maximum" : 987.6+        },+        "double" : {+          "type" : "number",+          "format" : "double",+          "minimum" : 67.8,+          "maximum" : 123.4+        },+        "string" : {+          "type" : "string",+          "pattern" : "/[a-z]/i"+        },+        "byte" : {+          "type" : "string",+          "format" : "byte",+          "pattern" : "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"+        },+        "binary" : {+          "type" : "string",+          "format" : "binary"+        },+        "date" : {+          "type" : "string",+          "format" : "date"+        },+        "dateTime" : {+          "type" : "string",+          "format" : "date-time"+        },+        "uuid" : {+          "type" : "string",+          "format" : "uuid"+        },+        "password" : {+          "type" : "string",+          "format" : "password",+          "minLength" : 10,+          "maxLength" : 64+        }+      }+    },+    "EnumClass" : {+      "type" : "string",+      "enum" : [ "_abc", "-efg", "(xyz)" ],+      "default" : "-efg"+    },+    "Enum_Test" : {+      "type" : "object",+      "properties" : {+        "enum_string" : {+          "type" : "string",+          "enum" : [ "UPPER", "lower", "" ]+        },+        "enum_integer" : {+          "type" : "integer",+          "format" : "int32",+          "enum" : [ 1, -1 ]+        },+        "enum_number" : {+          "type" : "number",+          "format" : "double",+          "enum" : [ 1.1, -1.2 ]+        },+        "outerEnum" : {+          "$ref" : "#/definitions/OuterEnum"+        }+      }+    },+    "AdditionalPropertiesClass" : {+      "type" : "object",+      "properties" : {+        "map_property" : {+          "type" : "object",+          "additionalProperties" : {+            "type" : "string"+          }+        },+        "map_of_map_property" : {+          "type" : "object",+          "additionalProperties" : {+            "type" : "object",+            "additionalProperties" : {+              "type" : "string"+            }+          }+        }+      }+    },+    "MixedPropertiesAndAdditionalPropertiesClass" : {+      "type" : "object",+      "properties" : {+        "uuid" : {+          "type" : "string",+          "format" : "uuid"+        },+        "dateTime" : {+          "type" : "string",+          "format" : "date-time"+        },+        "map" : {+          "type" : "object",+          "additionalProperties" : {+            "$ref" : "#/definitions/Animal"+          }+        }+      }+    },+    "List" : {+      "type" : "object",+      "properties" : {+        "123-list" : {+          "type" : "string"+        }+      }+    },+    "Client" : {+      "type" : "object",+      "properties" : {+        "client" : {+          "type" : "string"+        }+      }+    },+    "ReadOnlyFirst" : {+      "type" : "object",+      "properties" : {+        "bar" : {+          "type" : "string",+          "readOnly" : true+        },+        "baz" : {+          "type" : "string"+        }+      }+    },+    "hasOnlyReadOnly" : {+      "type" : "object",+      "properties" : {+        "bar" : {+          "type" : "string",+          "readOnly" : true+        },+        "foo" : {+          "type" : "string",+          "readOnly" : true+        }+      }+    },+    "Capitalization" : {+      "type" : "object",+      "properties" : {+        "smallCamel" : {+          "type" : "string"+        },+        "CapitalCamel" : {+          "type" : "string"+        },+        "small_Snake" : {+          "type" : "string"+        },+        "Capital_Snake" : {+          "type" : "string"+        },+        "SCA_ETH_Flow_Points" : {+          "type" : "string"+        },+        "ATT_NAME" : {+          "type" : "string",+          "description" : "Name of the pet\n"+        }+      }+    },+    "MapTest" : {+      "type" : "object",+      "properties" : {+        "map_map_of_string" : {+          "type" : "object",+          "additionalProperties" : {+            "type" : "object",+            "additionalProperties" : {+              "type" : "string"+            }+          }+        },+        "map_of_enum_string" : {+          "type" : "object",+          "additionalProperties" : {+            "type" : "string",+            "enum" : [ "UPPER", "lower" ]+          }+        }+      }+    },+    "ArrayTest" : {+      "type" : "object",+      "properties" : {+        "array_of_string" : {+          "type" : "array",+          "items" : {+            "type" : "string"+          }+        },+        "array_array_of_integer" : {+          "type" : "array",+          "items" : {+            "type" : "array",+            "items" : {+              "type" : "integer",+              "format" : "int64"+            }+          }+        },+        "array_array_of_model" : {+          "type" : "array",+          "items" : {+            "type" : "array",+            "items" : {+              "$ref" : "#/definitions/ReadOnlyFirst"+            }+          }+        }+      }+    },+    "NumberOnly" : {+      "type" : "object",+      "properties" : {+        "JustNumber" : {+          "type" : "number"+        }+      }+    },+    "ArrayOfNumberOnly" : {+      "type" : "object",+      "properties" : {+        "ArrayNumber" : {+          "type" : "array",+          "items" : {+            "type" : "number"+          }+        }+      }+    },+    "ArrayOfArrayOfNumberOnly" : {+      "type" : "object",+      "properties" : {+        "ArrayArrayNumber" : {+          "type" : "array",+          "items" : {+            "type" : "array",+            "items" : {+              "type" : "number"+            }+          }+        }+      }+    },+    "EnumArrays" : {+      "type" : "object",+      "properties" : {+        "just_symbol" : {+          "type" : "string",+          "enum" : [ ">=", "$" ]+        },+        "array_enum" : {+          "type" : "array",+          "items" : {+            "type" : "string",+            "enum" : [ "fish", "crab" ]+          }+        }+      }+    },+    "OuterEnum" : {+      "type" : "string",+      "enum" : [ "placed", "approved", "delivered" ]+    },+    "OuterNumber" : {+      "type" : "number"+    },+    "OuterString" : {+      "type" : "string"+    },+    "OuterBoolean" : {+      "type" : "boolean"+    },+    "OuterComposite" : {+      "type" : "object",+      "properties" : {+        "my_number" : {+          "$ref" : "#/definitions/OuterNumber"+        },+        "my_string" : {+          "$ref" : "#/definitions/OuterString"+        },+        "my_boolean" : {+          "$ref" : "#/definitions/OuterBoolean"+        }+      }     }   },   "externalDocs" : {

@@ -5,11 +5,11 @@ import Data.Text (Text, pack) import Data.Char (isSpace) import Data.List (sort)-import Data.Time.Calendar (Day(..))-import Data.Time.Clock (UTCTime(..), secondsToDiffTime)+import qualified Data.Time as TI import Test.QuickCheck import qualified Data.HashMap.Strict as HM import qualified Data.Set as Set+import qualified Data.ByteString.Lazy as BL  import ApproxEq import SwaggerPetstore.Model@@ -17,14 +17,34 @@ instance Arbitrary Text where   arbitrary = pack <$> arbitrary -instance Arbitrary Day where-  arbitrary = ModifiedJulianDay . (2000 +) <$> arbitrary-  shrink = (ModifiedJulianDay <$>) . shrink . toModifiedJulianDay+instance Arbitrary TI.Day where+  arbitrary = TI.ModifiedJulianDay . (2000 +) <$> arbitrary+  shrink = (TI.ModifiedJulianDay <$>) . shrink . TI.toModifiedJulianDay -instance Arbitrary UTCTime where+instance Arbitrary TI.UTCTime where   arbitrary =-    UTCTime <$> arbitrary <*> (secondsToDiffTime <$> choose (0, 86401))+    TI.UTCTime <$> arbitrary <*> (TI.secondsToDiffTime <$> choose (0, 86401)) +instance Arbitrary BL.ByteString where+    arbitrary = BL.pack <$> arbitrary+    shrink xs = BL.pack <$> shrink (BL.unpack xs)++instance Arbitrary ByteArray where+    arbitrary = ByteArray <$> arbitrary+    shrink (ByteArray xs) = ByteArray <$> shrink xs++instance Arbitrary Binary where+    arbitrary = Binary <$> arbitrary+    shrink (Binary xs) = Binary <$> shrink xs++instance Arbitrary DateTime where+    arbitrary = DateTime <$> arbitrary+    shrink (DateTime xs) = DateTime <$> shrink xs++instance Arbitrary Date where+    arbitrary = Date <$> arbitrary+    shrink (Date xs) = Date <$> shrink xs+ -- | Checks if a given list has no duplicates in _O(n log n)_. hasNoDups   :: (Ord a)@@ -37,66 +57,280 @@       , Set.size s' > Set.size s = go s' xs       | otherwise = False -instance ApproxEq Day where+instance ApproxEq TI.Day where   (=~) = (==)  -- * Models  +instance Arbitrary AdditionalPropertiesClass where+  arbitrary =+    AdditionalPropertiesClass+      <$> arbitrary -- additionalPropertiesClassMapProperty :: Maybe (Map.Map String Text)+      <*> arbitrary -- additionalPropertiesClassMapOfMapProperty :: Maybe (Map.Map String (Map.Map String Text))+    ++instance Arbitrary Animal where+  arbitrary =+    Animal+      <$> arbitrary -- animalClassName :: Text+      <*> arbitrary -- animalColor :: Maybe Text+    ++instance Arbitrary AnimalFarm where+  arbitrary =+    pure AnimalFarm+     + instance Arbitrary ApiResponse where   arbitrary =     ApiResponse-    <$> arbitrary -- apiResponseCode :: Maybe Int-    <*> arbitrary -- apiResponseType :: Maybe Text-    <*> arbitrary -- apiResponseMessage :: Maybe Text+      <$> arbitrary -- apiResponseCode :: Maybe Int+      <*> arbitrary -- apiResponseType :: Maybe Text+      <*> arbitrary -- apiResponseMessage :: Maybe Text      +instance Arbitrary ArrayOfArrayOfNumberOnly where+  arbitrary =+    ArrayOfArrayOfNumberOnly+      <$> arbitrary -- arrayOfArrayOfNumberOnlyArrayArrayNumber :: Maybe [[Double]]+    ++instance Arbitrary ArrayOfNumberOnly where+  arbitrary =+    ArrayOfNumberOnly+      <$> arbitrary -- arrayOfNumberOnlyArrayNumber :: Maybe [Double]+    ++instance Arbitrary ArrayTest where+  arbitrary =+    ArrayTest+      <$> arbitrary -- arrayTestArrayOfString :: Maybe [Text]+      <*> arbitrary -- arrayTestArrayArrayOfInteger :: Maybe [[Integer]]+      <*> arbitrary -- arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]+    ++instance Arbitrary Capitalization where+  arbitrary =+    Capitalization+      <$> arbitrary -- capitalizationSmallCamel :: Maybe Text+      <*> arbitrary -- capitalizationCapitalCamel :: Maybe Text+      <*> arbitrary -- capitalizationSmallSnake :: Maybe Text+      <*> arbitrary -- capitalizationCapitalSnake :: Maybe Text+      <*> arbitrary -- capitalizationScaEthFlowPoints :: Maybe Text+      <*> arbitrary -- capitalizationAttName :: Maybe Text+    + instance Arbitrary Category where   arbitrary =     Category-    <$> arbitrary -- categoryId :: Maybe Integer-    <*> arbitrary -- categoryName :: Maybe Text+      <$> arbitrary -- categoryId :: Maybe Integer+      <*> arbitrary -- categoryName :: Maybe Text      +instance Arbitrary ClassModel where+  arbitrary =+    ClassModel+      <$> arbitrary -- classModelClass :: Maybe Text+    ++instance Arbitrary Client where+  arbitrary =+    Client+      <$> arbitrary -- clientClient :: Maybe Text+    ++instance Arbitrary EnumArrays where+  arbitrary =+    EnumArrays+      <$> arbitrary -- enumArraysJustSymbol :: Maybe Text+      <*> arbitrary -- enumArraysArrayEnum :: Maybe [Text]+    ++instance Arbitrary EnumClass where+  arbitrary =+    pure EnumClass+     ++instance Arbitrary EnumTest where+  arbitrary =+    EnumTest+      <$> arbitrary -- enumTestEnumString :: Maybe Text+      <*> arbitrary -- enumTestEnumInteger :: Maybe Int+      <*> arbitrary -- enumTestEnumNumber :: Maybe Double+      <*> arbitrary -- enumTestOuterEnum :: Maybe OuterEnum+    ++instance Arbitrary FormatTest where+  arbitrary =+    FormatTest+      <$> arbitrary -- formatTestInteger :: Maybe Int+      <*> arbitrary -- formatTestInt32 :: Maybe Int+      <*> arbitrary -- formatTestInt64 :: Maybe Integer+      <*> arbitrary -- formatTestNumber :: Double+      <*> arbitrary -- formatTestFloat :: Maybe Float+      <*> arbitrary -- formatTestDouble :: Maybe Double+      <*> arbitrary -- formatTestString :: Maybe Text+      <*> arbitrary -- formatTestByte :: ByteArray+      <*> arbitrary -- formatTestBinary :: Maybe Binary+      <*> arbitrary -- formatTestDate :: Date+      <*> arbitrary -- formatTestDateTime :: Maybe DateTime+      <*> arbitrary -- formatTestUuid :: Maybe Text+      <*> arbitrary -- formatTestPassword :: Text+    ++instance Arbitrary HasOnlyReadOnly where+  arbitrary =+    HasOnlyReadOnly+      <$> arbitrary -- hasOnlyReadOnlyBar :: Maybe Text+      <*> arbitrary -- hasOnlyReadOnlyFoo :: Maybe Text+    ++instance Arbitrary MapTest where+  arbitrary =+    MapTest+      <$> arbitrary -- mapTestMapMapOfString :: Maybe (Map.Map String (Map.Map String Text))+      <*> arbitrary -- mapTestMapOfEnumString :: Maybe (Map.Map String Text)+    ++instance Arbitrary MixedPropertiesAndAdditionalPropertiesClass where+  arbitrary =+    MixedPropertiesAndAdditionalPropertiesClass+      <$> arbitrary -- mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text+      <*> arbitrary -- mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime+      <*> arbitrary -- mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map.Map String Animal)+    ++instance Arbitrary Model200Response where+  arbitrary =+    Model200Response+      <$> arbitrary -- model200ResponseName :: Maybe Int+      <*> arbitrary -- model200ResponseClass :: Maybe Text+    ++instance Arbitrary ModelList where+  arbitrary =+    ModelList+      <$> arbitrary -- modelList123List :: Maybe Text+    ++instance Arbitrary ModelReturn where+  arbitrary =+    ModelReturn+      <$> arbitrary -- modelReturnReturn :: Maybe Int+    ++instance Arbitrary Name where+  arbitrary =+    Name+      <$> arbitrary -- nameName :: Int+      <*> arbitrary -- nameSnakeCase :: Maybe Int+      <*> arbitrary -- nameProperty :: Maybe Text+      <*> arbitrary -- name123Number :: Maybe Int+    ++instance Arbitrary NumberOnly where+  arbitrary =+    NumberOnly+      <$> arbitrary -- numberOnlyJustNumber :: Maybe Double+    + instance Arbitrary Order where   arbitrary =     Order-    <$> arbitrary -- orderId :: Maybe Integer-    <*> arbitrary -- orderPetId :: Maybe Integer-    <*> arbitrary -- orderQuantity :: Maybe Int-    <*> arbitrary -- orderShipDate :: Maybe UTCTime-    <*> arbitrary -- orderStatus :: Maybe Text-    <*> arbitrary -- orderComplete :: Maybe Bool+      <$> arbitrary -- orderId :: Maybe Integer+      <*> arbitrary -- orderPetId :: Maybe Integer+      <*> arbitrary -- orderQuantity :: Maybe Int+      <*> arbitrary -- orderShipDate :: Maybe DateTime+      <*> arbitrary -- orderStatus :: Maybe Text+      <*> arbitrary -- orderComplete :: Maybe Bool      +instance Arbitrary OuterBoolean where+  arbitrary =+    pure OuterBoolean+     ++instance Arbitrary OuterComposite where+  arbitrary =+    OuterComposite+      <$> arbitrary -- outerCompositeMyNumber :: Maybe OuterNumber+      <*> arbitrary -- outerCompositeMyString :: Maybe OuterString+      <*> arbitrary -- outerCompositeMyBoolean :: Maybe OuterBoolean+    ++instance Arbitrary OuterEnum where+  arbitrary =+    pure OuterEnum+     ++instance Arbitrary OuterNumber where+  arbitrary =+    pure OuterNumber+     ++instance Arbitrary OuterString where+  arbitrary =+    pure OuterString+     + instance Arbitrary Pet where   arbitrary =     Pet-    <$> arbitrary -- petId :: Maybe Integer-    <*> arbitrary -- petCategory :: Maybe Category-    <*> arbitrary -- petName :: Text-    <*> arbitrary -- petPhotoUrls :: [Text]-    <*> arbitrary -- petTags :: Maybe [Tag]-    <*> arbitrary -- petStatus :: Maybe Text+      <$> arbitrary -- petId :: Maybe Integer+      <*> arbitrary -- petCategory :: Maybe Category+      <*> arbitrary -- petName :: Text+      <*> arbitrary -- petPhotoUrls :: [Text]+      <*> arbitrary -- petTags :: Maybe [Tag]+      <*> arbitrary -- petStatus :: Maybe Text      +instance Arbitrary ReadOnlyFirst where+  arbitrary =+    ReadOnlyFirst+      <$> arbitrary -- readOnlyFirstBar :: Maybe Text+      <*> arbitrary -- readOnlyFirstBaz :: Maybe Text+    ++instance Arbitrary SpecialModelName where+  arbitrary =+    SpecialModelName+      <$> arbitrary -- specialModelNameSpecialPropertyName :: Maybe Integer+    + instance Arbitrary Tag where   arbitrary =     Tag-    <$> arbitrary -- tagId :: Maybe Integer-    <*> arbitrary -- tagName :: Maybe Text+      <$> arbitrary -- tagId :: Maybe Integer+      <*> arbitrary -- tagName :: Maybe Text       instance Arbitrary User where   arbitrary =     User-    <$> arbitrary -- userId :: Maybe Integer-    <*> arbitrary -- userUsername :: Maybe Text-    <*> arbitrary -- userFirstName :: Maybe Text-    <*> arbitrary -- userLastName :: Maybe Text-    <*> arbitrary -- userEmail :: Maybe Text-    <*> arbitrary -- userPassword :: Maybe Text-    <*> arbitrary -- userPhone :: Maybe Text-    <*> arbitrary -- userUserStatus :: Maybe Int+      <$> arbitrary -- userId :: Maybe Integer+      <*> arbitrary -- userUsername :: Maybe Text+      <*> arbitrary -- userFirstName :: Maybe Text+      <*> arbitrary -- userLastName :: Maybe Text+      <*> arbitrary -- userEmail :: Maybe Text+      <*> arbitrary -- userPassword :: Maybe Text+      <*> arbitrary -- userPhone :: Maybe Text+      <*> arbitrary -- userUserStatus :: Maybe Int+    ++instance Arbitrary Cat where+  arbitrary =+    Cat+      <$> arbitrary -- catClassName :: Text+      <*> arbitrary -- catColor :: Maybe Text+      <*> arbitrary -- catDeclawed :: Maybe Bool+    ++instance Arbitrary Dog where+  arbitrary =+    Dog+      <$> arbitrary -- dogClassName :: Text+      <*> arbitrary -- dogColor :: Maybe Text+      <*> arbitrary -- dogBreed :: Maybe Text       

@@ -19,10 +19,40 @@ main =   hspec $ modifyMaxSize (const 10) $   do describe "JSON instances" $-       do propMimeEq MimeJSON (Proxy :: Proxy ApiResponse)+       do propMimeEq MimeJSON (Proxy :: Proxy AdditionalPropertiesClass)+          propMimeEq MimeJSON (Proxy :: Proxy Animal)+          propMimeEq MimeJSON (Proxy :: Proxy AnimalFarm)+          propMimeEq MimeJSON (Proxy :: Proxy ApiResponse)+          propMimeEq MimeJSON (Proxy :: Proxy ArrayOfArrayOfNumberOnly)+          propMimeEq MimeJSON (Proxy :: Proxy ArrayOfNumberOnly)+          propMimeEq MimeJSON (Proxy :: Proxy ArrayTest)+          propMimeEq MimeJSON (Proxy :: Proxy Capitalization)           propMimeEq MimeJSON (Proxy :: Proxy Category)+          propMimeEq MimeJSON (Proxy :: Proxy ClassModel)+          propMimeEq MimeJSON (Proxy :: Proxy Client)+          propMimeEq MimeJSON (Proxy :: Proxy EnumArrays)+          propMimeEq MimeJSON (Proxy :: Proxy EnumClass)+          propMimeEq MimeJSON (Proxy :: Proxy EnumTest)+          propMimeEq MimeJSON (Proxy :: Proxy FormatTest)+          propMimeEq MimeJSON (Proxy :: Proxy HasOnlyReadOnly)+          propMimeEq MimeJSON (Proxy :: Proxy MapTest)+          propMimeEq MimeJSON (Proxy :: Proxy MixedPropertiesAndAdditionalPropertiesClass)+          propMimeEq MimeJSON (Proxy :: Proxy Model200Response)+          propMimeEq MimeJSON (Proxy :: Proxy ModelList)+          propMimeEq MimeJSON (Proxy :: Proxy ModelReturn)+          propMimeEq MimeJSON (Proxy :: Proxy Name)+          propMimeEq MimeJSON (Proxy :: Proxy NumberOnly)           propMimeEq MimeJSON (Proxy :: Proxy Order)+          propMimeEq MimeJSON (Proxy :: Proxy OuterBoolean)+          propMimeEq MimeJSON (Proxy :: Proxy OuterComposite)+          propMimeEq MimeJSON (Proxy :: Proxy OuterEnum)+          propMimeEq MimeJSON (Proxy :: Proxy OuterNumber)+          propMimeEq MimeJSON (Proxy :: Proxy OuterString)           propMimeEq MimeJSON (Proxy :: Proxy Pet)+          propMimeEq MimeJSON (Proxy :: Proxy ReadOnlyFirst)+          propMimeEq MimeJSON (Proxy :: Proxy SpecialModelName)           propMimeEq MimeJSON (Proxy :: Proxy Tag)           propMimeEq MimeJSON (Proxy :: Proxy User)+          propMimeEq MimeJSON (Proxy :: Proxy Cat)+          propMimeEq MimeJSON (Proxy :: Proxy Dog)