h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv w x y z { | } ~                                                                                                                                                 Safe-Inferred)*1servant-serverNormally context entries are accessed by their types. In case you need to have multiple values of the same type in your  & and need to access them, we provide -. You can think of it as sub-namespaces for  s. servant-server0This class is used to access context entries in  s.  1 returns the first value where the type matches:7getContextEntry (True :. False :. EmptyContext) :: BoolTrueIf the   does not contain an entry of the requested type, you'll get an error:9getContextEntry (True :. False :. EmptyContext) :: String.../...No instance for (HasContextEntry '[] [Char])... servant-serverAppend two type-level lists.Hint: import it as "import Servant.Server (type (.++)) servant-server 4s are used to pass values to combinators. (They are not meant to be used to pass parameters to your handlers, i.e. they should not replace any custom %-monad-stack that you're using with  hoistServer.) If you don't use combinators that require any context entries, you can just use  as always.6If you are using combinators that require a non-empty   you have to use  and pass it a  8 that contains all the values your combinators need. A   is essentially a heterogeneous list and accessing the elements is being done by type (see  ). The parameter of the type   is a type-level list reflecting the types of the contained context entries. To create a  ! with entries, use the operator (): :type True :. () :. EmptyContext1True :. () :. EmptyContext :: Context '[Bool, ()]servant-serverAppend two contexts.servant-server allows you to access s. Usually you won't have to use it yourself but instead use a combinator like . This is how  works::set -XFlexibleContexts%let subContext = True :. EmptyContext:type subContextsubContext :: Context '[Bool]let parentContext = False :. (NamedContext subContext :: NamedContext "subContext" '[Bool]) :. EmptyContext:type parentContextparentContext :: Context '[Bool, NamedContext "subContext" '[Bool]]descendIntoNamedContext (Proxy :: Proxy "subContext") parentContext :: Context '[Bool]True :. EmptyContext      5 Safe-Inferred"%&6#G servant-server Multiple ChoicesExample: failingHandler :: Handler () failingHandler = throwError $ err300 { errBody = "I can't choose." }servant-server Moved PermanentlyExample: ?failingHandler :: Handler () failingHandler = throwError err301 servant-server  FoundExample: ?failingHandler :: Handler () failingHandler = throwError err302!servant-server! See OtherExample: ?failingHandler :: Handler () failingHandler = throwError err303"servant-server" Not ModifiedExample: ?failingHandler :: Handler () failingHandler = throwError err304#servant-server# Use ProxyExample: ?failingHandler :: Handler () failingHandler = throwError err305$servant-server$ Temporary RedirectExample: ?failingHandler :: Handler () failingHandler = throwError err307%servant-server% Bad RequestExample: failingHandler :: Handler () failingHandler = throwError $ err400 { errBody = "Your request makes no sense to me." }&servant-server& UnauthorizedExample: failingHandler :: Handler () failingHandler = throwError $ err401 { errBody = "Your credentials are invalid." }'servant-server' Payment RequiredExample: failingHandler :: Handler () failingHandler = throwError $ err402 { errBody = "You have 0 credits. Please give me $$$." }(servant-server( ForbiddenExample: failingHandler :: Handler () failingHandler = throwError $ err403 { errBody = "Please login first." })servant-server) Not FoundExample: failingHandler :: Handler () failingHandler = throwError $ err404 { errBody = "Are you lost?" }*servant-server* Method Not AllowedExample: failingHandler :: Handler () failingHandler = throwError $ err405 { errBody = "Your account privileges does not allow for this. Please pay $$$." }+servant-server+ Not AcceptableExample: ?failingHandler :: Handler () failingHandler = throwError err406,servant-server, Proxy Authentication RequiredExample: ?failingHandler :: Handler () failingHandler = throwError err407-servant-server- ConflictExample: failingHandler :: Handler () failingHandler = throwError $ err409 { errBody = "Transaction conflicts with 59879cb56c7c159231eeacdd503d755f7e835f74" }.servant-server. GoneExample: failingHandler :: Handler () failingHandler = throwError $ err410 { errBody = "I know it was here at some point, but.. I blame bad luck." }/servant-server/ Length RequiredExample: ?failingHandler :: Handler () failingHandler = throwError err4110servant-server0 Precondition FailedExample: failingHandler :: Handler () failingHandler = throwError $ err412 { errBody = "Precondition fail: x < 42 && y > 57" }1servant-server1 Request Entity Too LargeExample: failingHandler :: Handler () failingHandler = throwError $ err413 { errBody = "Request exceeded 64k." }2servant-server2 Request-URI Too LargeExample: failingHandler :: Handler () failingHandler = throwError $ err414 { errBody = "Maximum length is 64." }3servant-server3 Unsupported Media TypeExample: failingHandler :: Handler () failingHandler = throwError $ err415 { errBody = "Supported media types: gif, png" }4servant-server4 Request range not satisfiableExample: failingHandler :: Handler () failingHandler = throwError $ err416 { errBody = "Valid range is [0, 424242]." }5servant-server5 Expectation FailedExample: failingHandler :: Handler () failingHandler = throwError $ err417 { errBody = "I found a quux in the request. This isn't going to work." }6servant-server6 Expectation FailedExample: failingHandler :: Handler () failingHandler = throwError $ err418 { errBody = "Apologies, this is not a webserver but a teapot." }7servant-server7 Unprocessable EntityExample: failingHandler :: Handler () failingHandler = throwError $ err422 { errBody = "I understood your request, but can't process it." }8servant-server8 Internal Server ErrorExample: failingHandler :: Handler () failingHandler = throwError $ err500 { errBody = "Exception in module A.B.C:55. Have a great day!" }9servant-server9 Not ImplementedExample: failingHandler :: Handler () failingHandler = throwError $ err501 { errBody = "/v1/foo is not supported with quux in the request." }:servant-server: Bad GatewayExample: failingHandler :: Handler () failingHandler = throwError $ err502 { errBody = "Tried gateway foo, bar, and baz. None responded." };servant-server; Service UnavailableExample: failingHandler :: Handler () failingHandler = throwError $ err503 { errBody = "We're rewriting in PHP." }<servant-server< Gateway Time-outExample: failingHandler :: Handler () failingHandler = throwError $ err504 { errBody = "Backend foobar did not respond in 5 seconds." }=servant-server= HTTP Version not supportedExample usage: failingHandler :: Handler () failingHandler = throwError $ err505 { errBody = "I support HTTP/4.0 only." }' !"#$%&'()*+,-./0123456789:;<=' !"#$%&'()*+,-./0123456789:;<= Safe-Inferred 8$Eservant-server8The result of matching against a path in the route tree.Fservant-server Keep trying other paths. The  ServantError should only be 404, 405 or 406.Gservant-serverDon't try other paths.BDCEHGFEHGFBDC Safe-Inferred%;Xservant-serverthe request, the field pathInfo may be modified by url routingXYXY Safe-Inferred ;%sZ\[]Z\[] Safe-Inferred01) kservant-server$This formatter does not get neither  nor error message.lservant-serverA custom formatter for errors produced by parsing combinators like  or .A  argument described the concrete combinator that raised the error, allowing formatter to customize the message for different combinators.A full 3 is also passed so that the formatter can react to Accept header, for example.mservant-server:A collection of error formatters for different situations.)If you need to override one of them, use t with record update syntax.oservant-server+Format error from parsing the request body.pservant-server8Format error from parsing url parts or query parameters.qservant-server*Format error from parsing request headers.rservant-server Format error for not found URLs.sservant-server ( that contains default error formatters.tservant-serverDefault formatters will just return HTTP 400 status code with error message as response body. jklmnopqrstu mnopqrlkstju  Safe-Inferred")*82vservant-serverDatatype used for representing and debugging the structure of a router. Abstracts from the handlers at the leaves.Two 3s can be structurally compared by computing their v using % and then testing for equality, see .{servant-server$Internal representation of a router.The first argument describes an environment type that is expected as extra input by the routers at the leaves. The environment is filled while running the router, with path components that can be used to process captures.|servant-serverthe map contains routers for subpaths (first path component used for lookup and removed afterwards), the list contains handlers for the empty path, to be tried in order}servant-serverfirst path component is passed to the child router in its environment and removed afterwards~servant-serverall path components are passed to the child router in its environment and are removed afterwardsservant-server3to be used for routes we do not know anything aboutservant-server&left-biased choice between two routersservant-server5Smart constructor for a single static path component.servant-serverSmart constructor for a leaf, i.e., a router that expects the empty path.servant-serverSmart constructor for the choice between routers. We currently optimize the following cases:Two static routers can be joined by joining their maps and concatenating their leaf-lists.=Two dynamic routers can be joined by joining their codomains.Choice nodes can be reordered.servant-server"Compute the structure of a router.2Assumes that the request or text being passed in  WithRequest or }7 does not affect the structure of the underlying tree.servant-server%Compare the structure of two routers.servant-server?Provide a textual representation of the structure of a router.servant-server,Apply a transformation to the response of a .servant-server%Interpret a router as an application.servant-serverTry a list of routing applications in order. We stop as soon as one fails fatally or succeeds. If all fail normally, we pick the "best" error.vzyxw{~}|{~}|vzyxw  Safe-Inferred5 servant-serverComputations used in a Delayed can depend on the incoming , may perform , and result in a E, meaning they can either succeed, fail (with the possibility to recover), or fail fatally.servant-server Fail with the option to recover.servant-server2Fail fatally, i.e., without any option to recover.servant-server$Gain access to the incoming request.  Safe-Inferred%&)*F servant-serverA  is a representation of a handler with scheduled delayed checks that can trigger errors."Why would we want to delay checks?There are two reasons: In a straight-forward implementation, the order in which we perform checks will determine the error we generate. This is because once an error occurs, we would abort and not perform any subsequent checks, but rather return the current error.This is not a necessity: we could continue doing other checks, and choose the preferred error. However, that would in general mean more checking, which leads us to the other reason. We really want to avoid doing certain checks too early. For example, captures involve parsing, and are much more costly than static route matches. In particular, if several paths contain the "same" capture, we'd like as much as possible to avoid trying the same parse many times. Also tricky is the request body. Again, this involves parsing, but also, WAI makes obtaining the request body a side-effecting operation. We could/can work around this by manually caching the request body, but we'd rather keep the number of times we actually try to decode the request body to an absolute minimum.We prefer to have the following relative priorities of error codes: 404 405 (bad method) 401 (unauthorized) 415 (unsupported media type) 406 (not acceptable) 400 (bad request) Therefore, while routing, we delay most checks so that they will ultimately occur in the right order.A  contains many delayed blocks of tests, and the actual handler: Delayed captures. These can actually cause 404, and while they're costly, they should be done first among the delayed checks (at least as long as we do not decouple the check order from the error reporting, see above). Delayed captures can provide inputs to the actual handler.Method check(s). This can cause a 405. On success, it does not provide an input for the handler. Method checks are comparatively cheap.*Authentication checks. This can cause 401.Accept and content type header checks. These checks can cause 415 and 406 errors.Query parameter checks. They require parsing and can cause 400 if the parsing fails. Query parameter checks provide inputs to the handlerHeader Checks. They also require parsing and can cause 400 if parsing fails.1Body check. The request body check can cause 400.servant-serverA  without any stored checks.servant-server.Add a capture to the end of the capture block.servant-server4Add a parameter check to the end of the params blockservant-server4Add a parameter check to the end of the params blockservant-server2Add a method check to the end of the method block.servant-server/Add an auth check to the end of the auth block.servant-server;Add a content type and body checks around parameter checks.We'll report failed content type check (415), before trying to parse query parameters (400). Which, in turn, happens before request body parsing.servant-serverAdd an accept header check before handling parameters. In principle, we'd like to take a bad body (400) response take precedence over a failed accept check (406). BUT to allow streaming the body, we cannot run the body check and then still backtrack. We therefore do the accept check before the body check, when we can still backtrack. There are other solutions to this, but they'd be more complicated (such as delaying the body check further so that it can still be run in a situation where we'd otherwise report 406).servant-serverMany combinators extract information that is passed to the handler without the possibility of failure. In such a case,  can be used.servant-serverRun a delayed server. Performs all scheduled operations in order, and passes the results from the capture and body blocks on to the actual handler.This should only be called once per request; otherwise the guarantees about effect and HTTP error ordering break down.servant-serverRuns a delayed server and the resulting action. Takes a continuation that lets us send a response. Also takes a continuation for how to turn the result of the delayed server into a response.servant-servercontent type checkservant-server body check  Safe-Inferred"68;Ieservant-server:Datatype wrapping a function used to check authentication.servant-serverservant-server's current implementation of basic authentication is not immune to certain kinds of timing attacks. Decoding payloads does not take a fixed amount of time.*The result of authentication/authorizationservant-server.Internal method to make a basic-auth challengeservant-serverFind and decode an  Authorization& header from the request as Basic Authservant-serverRun and check basic authentication, returning the appropriate http error per the spec.   None"/0126iservant-server9This class is a necessary evil: in the implementation of  for  api0, we essentially need the quantified constraint  forall m.  m to hold.8We cannot require do that directly as the definition of % contains type family applications ( and ). The trick is to hide those type family applications behind a typeclass providing evidence for  api m0 in the form of a dictionary, and require that  forall m.  api m instead.Users shouldn't have to worry about this class, as the only possible instance is provided in this module for all record APIs.servant-serverSet of constraints required to convert to / from vanilla server types.servant-serverA type that specifies that an API record contains a server implementation.servant-server>Singleton type representing a server that serves an empty API.servant-server Server for servant-serverIgnore  in server handlers. See  0https://ietf.org/rfc/rfc2616.html#section-15.1.3 for more details.Example: type MyApi = "books" :> Fragment Text :> Get '[JSON] [Book] server :: Server MyApi server = getBooks where getBooks :: Handler [Book] getBooks = ...return all books...servant-serverBasic Authenticationservant-serverIgnore  in server handlers.servant-serverIgnore  in server handlers.servant-server+Make sure the incoming request starts with "/path"5, strip it and pass the rest of the request path to api.servant-server If you use ReqBody in one of the endpoints for your API, this automatically requires your server-side handler to be a function that takes an argument of the type specified by ReqBody. The  Content-Type header is inspected, and the list provided is used to attempt deserialization. If the request does not have a  Content-Type header, it is treated as application/octet-stream (as specified in  2http://tools.ietf.org/html/rfc7231#section-3.1.1.5RFC 7231 section 3.1.1.5). This lets servant worry about extracting it from the request and turning it into a value of the type you specify.All it asks is for a FromJSON instance.Example: type MyApi = "books" :> ReqBody '[JSON] Book :> Post '[JSON] Book server :: Server MyApi server = postBook where postBook :: Book -> Handler Book postBook book = ...insert into your db...servant-serverJust pass the request to the underlying application and serve its response.Example: type MyApi = "images" :> Raw server :: Server MyApi server = serveDirectory "/var/www/images"servant-server If you use  "published" in one of the endpoints for your API, this automatically requires your server-side handler to be a function that takes an argument of type .Example: type MyApi = "books" :> QueryFlag "published" :> Get '[JSON] [Book] server :: Server MyApi server = getBooks where getBooks :: Bool -> Handler [Book] getBooks onlyPublished = ...return all books, or only the ones that are already published, depending on the argument...servant-server If you use  "authors" Text in one of the endpoints for your API, this automatically requires your server-side handler to be a function that takes an argument of type [].This lets servant worry about looking up 0 or more values in the query string associated to authors and turning each of them into a value of the type you specify.=You can control how the individual values are converted from 2 to your type by simply providing an instance of  for your type.Example: type MyApi = "books" :> QueryParams "authors" Text :> Get '[JSON] [Book] server :: Server MyApi server = getBooksBy where getBooksBy :: [Text] -> Handler [Book] getBooksBy authors = ...return all books by these authors...servant-server If you use  QueryParam "author" Text in one of the endpoints for your API, this automatically requires your server-side handler to be a function that takes an argument of type  .This lets servant worry about looking it up in the query string and turning it into a value of the type you specify, enclosed in ?, because it may not be there and servant would then hand you .,You can control how it'll be converted from 2 to your type by simply providing an instance of  for your type.Example: type MyApi = "books" :> QueryParam "author" Text :> Get '[JSON] [Book] server :: Server MyApi server = getBooksBy where getBooksBy :: Maybe Text -> Handler [Book] getBooksBy Nothing = ...return all books... getBooksBy (Just author) = ...return books by the given author...servant-server If you use Header in one of the endpoints for your API, this automatically requires your server-side handler to be a function that takes an argument of the type specified by Header. This lets servant worry about extracting it from the request and turning it into a value of the type you specify.All it asks is for a  instance.Example: newtype Referer = Referer Text deriving (Eq, Show, FromHttpApiData) -- GET /view-my-referer type MyApi = "view-my-referer" :> Header "Referer" Referer :> Get '[JSON] Referer server :: Server MyApi server = viewReferer where viewReferer :: Referer -> Handler referer viewReferer referer = return refererservant-server If you use  in one of the endpoints for your API, this automatically requires your server-side handler to be a function that takes an argument of a list of the type specified by the . This lets servant worry about getting values from the URL and turning them into values of the type you specify..You can control how they'll be converted from 2 to your type by simply providing an instance of  for your type.Example: type MyApi = "src" :> CaptureAll "segments" Text :> Get '[JSON] SourceFile server :: Server MyApi server = getSourceFile where getSourceFile :: [Text] -> Handler Book getSourceFile pathSegments = ...servant-server If you use Capture in one of the endpoints for your API, this automatically requires your server-side handler to be a function that takes an argument of the type specified by the Capture. This lets servant worry about getting it from the URL and turning it into a value of the type you specify.,You can control how it'll be converted from 2 to your type by simply providing an instance of  for your type.Example: type MyApi = "books" :> Capture "isbn" Text :> Get '[JSON] Book server :: Server MyApi server = getBook where getBook :: Text -> Handler Book getBook isbn = ...servant-server A server for a  b first tries to match the request against the route represented by a and if it fails tries b7. You must provide a request handler for each route. type MyApi = "books" :> Get '[JSON] [Book] -- GET /books :<|> "books" :> ReqBody Book :> Post '[JSON] Book -- POST /books server :: Server MyApi server = listAllBooks :<|> postBook where listAllBooks = ... postBook book = ...servant-serverThe server for an  is . type MyApi = "nothing" :> EmptyApi server :: Server MyApi server = emptyServerservant-server/This instance prevents from accidentally using -> instead of serve (Proxy :: Proxy (Capture "foo" Int -> Get '[JSON] Int)) (error "...")..."...No instance HasServer (a -> b).3...Maybe you have used '->' instead of ':>' between...Capture' '[] "foo" Int...and...Verb 'GET 200 '[JSON] Int...:undefined :: Server (Capture "foo" Int -> Get '[JSON] Int)..."...No instance HasServer (a -> b).3...Maybe you have used '->' instead of ':>' between...Capture' '[] "foo" Int...and...Verb 'GET 200 '[JSON] Int...  !"#$%&'()*+,-./0123456789:;<=BCDEHFGXYZ[\]jklmrqpnostuvzywx{~|} Safe-Inferred"/12kservant-server for  handlers. Takes a value of any of the members of the open union, and will construct a union value in an  (eg. ). Safe-Inferred /1yservant-serverConstraints that need to be satisfied on a context for it to be passed to .Typically, this will add default context entries to the context. You shouldn't typically need to worry about these constraints, but if you write a helper function that wraps ,, you might need to include this constraint.servant-server2 allows you to implement an API and produce a wai .Example: type MyApi = "books" :> Get '[JSON] [Book] -- GET /books :<|> "books" :> ReqBody '[JSON] Book :> Post '[JSON] Book -- POST /books server :: Server MyApi server = listAllBooks :<|> postBook where listAllBooks = ... postBook book = ... myApi :: Proxy MyApi myApi = Proxy app :: Application app = serve myApi server main :: IO () main = Network.Wai.Handler.Warp.run 8080 appservant-serverLike (, but allows you to pass custom context.t will always be appended to the end of the passed context, but if you pass your own formatter, it will override the default one.servant-server A general  function that allows you to pass a custom context and hoisting function to apply on all routes.servant-serverHoist server implementation.Sometimes our cherished Z monad isn't quite the type you'd like for your handlers. Maybe you want to thread some configuration in a Reader monad. Or have your types ensure that your handlers don't do any IO. Use  (a successor of now deprecated enter).With , you can provide a function, to convert any number of endpoints from one type constructor to another. For exampleNote:  Raw* can also be entered. It will be retagged.import Control.Monad.Readertype ReaderAPI = "ep1" :> Get '[JSON] Int :<|> "ep2" :> Get '[JSON] String :<|> Raw :<|> EmptyAPI(let readerApi = Proxy :: Proxy ReaderAPIlet readerServer = return 1797 :<|> ask :<|> Tagged (error "raw server") :<|> emptyServer :: ServerT ReaderAPI (Reader String)$let nt x = return (runReader x "hi")let mainServer = hoistServer readerApi nt readerServer :: Server ReaderAPIservant-server The function  produces a textual description of the internal router layout for debugging purposes. Note that the router layout is determined just by the API, not by the handlers.Example:For the following API type API = "a" :> "d" :> Get '[JSON] NoContent :<|> "b" :> Capture "x" Int :> Get '[JSON] Bool :<|> "c" :> Put '[JSON] Bool :<|> "a" :> "e" :> Get '[JSON] Int :<|> "b" :> Capture "x" Int :> Put '[JSON] Bool :<|> Rawwe get the following output: / JJ a/ J JJ d/ J J JJ@ J JJ e/ J JJ@ JJ b/ J JJ / J JJ@ J J J JJ@ JJ c/ J JJ@ J JJ Explanation of symbols: J2Normal lines reflect static branching via a table.a/%Nodes reflect static path components.J@Leaves reflect endpoints. /8This is a part of the API we do not know anything about.JDashed lines suggest a dynamic choice between the part above and below. If there is a success for fatal failure in the first part, that one takes precedence. If both parts fail, the "better" error code will be returned.servant-server Variant of  that takes an additional  .  !"#$%&'()*+,-./0123456789:;<=YZ[\]klmrqopstYZ[\]   !"#$%&'()*+,-./0123456789:;<=lkmopqrst Safe-Inferred)servant-server2Serve anything under the specified directory as a  endpoint. type MyApi = "static" :> Raw server :: Server MyApi server = serveDirectoryWebApp "/var/www" would capture any request to /static/ and look for   under /var/www.It will do its best to guess the MIME type for that file, based on the extension, and send an appropriate  Content-Type header if possible.If your goal is to serve HTML, CSS and Javascript files that use the rest of the API as a webapp backend, you will most likely not want the static files to be hidden behind a /static/+ prefix. In that case, remember to put the ( handler in the last position, because servant* will try to match the handlers in order.Corresponds to the   value.servant-serverSame as  , but uses .servant-serverSame as  , but uses .servant-serverUses .servant-server Alias for /. Lets you serve a directory with arbitrary . Useful when you want particular settings not covered by the four other variants. This is the most flexible method.servant-serverSame as . It used to be the only file serving function in servant pre-0.10 and will be kept around for a few versions, but is deprecated. Safe-Inferred 1,servant-server(Transform a record of routes into a WAI .servant-server:Transform a record of routes with custom monad into a WAI , by providing a transformation to bring each handler back in the Z monad.servant-server:Transform a record of routes with custom monad into a WAI , while using the given   to serve the application (contexts are typically used by auth-related combinators in servant, e.g to hold auth checks) and the given transformation to map all the handlers back to the Z monad.servant-server'Transform a record of endpoints into a .servant-server'Transform a record of endpoints into a  m.0You can see an example usage of this function  https://docs.servant.dev/en/stable/cookbook/generic/Generic.html#using-generics-together-with-a-custom-monadin the Servant Cookbook.servant-server argument to come back to Zservant-server$your record full of request handlersservant-server argument to come back to Zservant-server$your record full of request handlersservant-serverthe   to serve the application with Safe-Inferredn  !"#$%&'()*+,-./0123456789:;<=YZ[\]klmrqopst Safe-Inferred06;servant-server$Handlers for AuthProtected resources4NOTE: THIS API IS EXPERIMENTAL AND SUBJECT TO CHANGEservant-serverSpecify the type of data returned after we've authenticated a request. quite often this is some User datatype.4NOTE: THIS API IS EXPERIMENTAL AND SUBJECT TO CHANGEservant-server4NOTE: THIS API IS EXPERIMENTAL AND SUBJECT TO CHANGEservant-serverKnown orphan instance. Safe-Inferred ! " "#$%&&'()*+,)-./01234456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^^_`abcdefghijklmnopqrstuuvwxyz{|}~                                                                                                                                                        #,servant-server-0.19.2-JdyS7TrnbMo8DUFKokM3clServantServant.ServerServant.Server.Internal.Context#Servant.Server.Internal.ServerError#Servant.Server.Internal.RouteResult*Servant.Server.Internal.RoutingApplicationServant.Server.Internal.Handler&Servant.Server.Internal.ErrorFormatterServant.Server.Internal.Router!Servant.Server.Internal.DelayedIOServant.Server.Internal.Delayed!Servant.Server.Internal.BasicAuthServant.Server.InternalServant.Server.UVerbServant.Server.StaticFilesServant.Server.Generic Servant.Server.Experimental.AuthControl.Monad.Trans.ReaderReaderTserveserveWithContextServant.API.WithNamedContextWithNamedContextServant.Utils.StaticFilesbase Data.ProxyProxy mtl-2.2.2Control.Monad.Error.Class throwError%tagged-0.8.6.1-3kXCUTtTgM1AuItZIsF4Gt Data.TaggedunTaggedTagged wai-3.2.3-GJ93JXcVtKMJ4Od8PN5oi0 Network.Wai Application NamedContextHasContextEntrygetContextEntry.++Context EmptyContext:.descendIntoNamedContext $fEqContext $fEqContext0 $fShowContext$fShowContext0$fHasContextEntry:val$fHasContextEntry:val0 ServerError errHTTPCodeerrReasonPhraseerrBody errHeadersresponseServerErrorerr300err301err302err303err304err305err307err400err401err402err403err404err405err406err407err409err410err411err412err413err414err415err416err417err418err422err500err501err502err503err504err505$fExceptionServerError$fShowServerError$fEqServerError$fReadServerError RouteResultTrunRouteResultT RouteResultFail FailFatalRoute$fMonadRouteResult$fApplicativeRouteResult$fMonadThrowRouteResultT$fMonadTransControlRouteResultT$fMonadBaseControlbRouteResultT$fMonadBasebRouteResultT$fMonadIORouteResultT$fMonadRouteResultT$fApplicativeRouteResultT$fMonadTransRouteResultT$fFunctorRouteResultT$fEqRouteResult$fShowRouteResult$fReadRouteResult$fFunctorRouteResultRoutingApplication toApplicationHandler runHandler' runHandler$fMonadBaseControlIOHandler$fMonadBaseIOHandler$fMonadFailHandler$fFunctorHandler$fApplicativeHandler$fMonadHandler$fMonadIOHandler$fGenericHandler$fMonadErrorServerErrorHandler$fMonadThrowHandler$fMonadCatchHandler$fMonadMaskHandlerMkContextWithErrorFormatterNotFoundErrorFormatterErrorFormatterErrorFormattersbodyParserErrorFormatterurlParseErrorFormatterheaderParseErrorFormatternotFoundErrorFormatterDefaultErrorFormattersdefaultErrorFormattersmkContextWithErrorFormatterRouterStructureStaticRouterStructureCaptureRouterStructureRawRouterStructureChoiceStructureRouter' StaticRouter CaptureRouterCaptureAllRouter RawRouterChoice CaptureHint captureName captureTypeRouter toCaptureTag toCaptureTags pathRouter leafRouterchoicerouterStructure sameStructure routerLayout tweakResponse runRouter runRouterEnv runChoice worseHTTPCode$fEqRouterStructure$fShowRouterStructure$fFunctorRouter'$fShowCaptureHint$fEqCaptureHint DelayedIO runDelayedIO'liftRouteResult runDelayedIO delayedFaildelayedFailFatal withRequest$fMonadBaseControlIODelayedIO$fMonadBaseIODelayedIO$fFunctorDelayedIO$fApplicativeDelayedIO$fMonadDelayedIO$fMonadIODelayedIO$fMonadReaderRequestDelayedIO$fMonadThrowDelayedIO$fMonadResourceDelayedIODelayed capturesDmethodDauthDacceptDcontentDparamsDheadersDbodyDserverD emptyDelayed addCaptureaddParameterCheckaddHeaderCheckaddMethodCheck addAuthCheck addBodyCheckaddAcceptCheck passToServer runDelayed runAction$fFunctorDelayedBasicAuthCheckunBasicAuthCheckBasicAuthResult Unauthorized BadPassword NoSuchUser AuthorizedmkBAChallengerHdr decodeBAHdr runBasicAuth$fGenericBasicAuthCheck$fFunctorBasicAuthCheck$fEqBasicAuthResult$fShowBasicAuthResult$fReadBasicAuthResult$fGenericBasicAuthResult$fFunctorBasicAuthResultGServer gServerProofGServerConstraintsAsServer AsServerTHasServerArrowTypeError EmptyServerServer HasServerServerTroutehoistServerWithContextallowedMethodHead allowedMethod methodCheck acceptCheck methodRouternoContentRouter streamRouter emptyServer ct_wildcardgetAcceptHeader$fHasServerTYPE:>context$fHasServerkapicontext$fHasServerTYPE:>context0$fHasServerTYPE:>context1&$fHasServerTYPEWithNamedContextcontext$fHasServerTYPE:>context2$fHasServerTYPE:>ctx$fHasServerTYPE:>ctx0$fHasServerTYPE:>context3$fHasServerTYPE:>context4$fHasServerTYPE:>context5$fHasServerTYPE:>context6$fHasServerTYPE:>context7$fHasServerTYPE:>context8$fHasServerTYPE:>context9$fHasServerTYPERawcontext$fHasServerTYPE:>context10$fHasServerTYPE:>context11$fHasServerTYPE:>context12$fHasServerTYPE:>context13$fHasServerTYPEStreamcontext$fHasServerTYPEStreamcontext0#$fHasServerTYPENoContentVerbcontext$fHasServerTYPEVerbcontext$fHasServerTYPEVerbcontext0$fHasServerTYPE:>context14$fHasServerTYPE:>context15$fHasServerTYPE:<|>context$fHasServerTYPEEmptyAPIcontext$fHasServerTYPEFUNcontext$fGenericModeAsServerT!$fHasServerTYPENamedRoutescontext $fGServerapim$fEqEmptyServer$fShowEmptyServer$fBoundedEmptyServer$fEnumEmptyServerIsServerResourcerespond$fIsServerResourcectsWithStatus$fIsServerResourcectsHeaders$fIsServerResourcectsa$fHasServerTYPEUVerbcontext ServerContextserveWithContextT hoistServerlayoutlayoutWithContextserveDirectoryWebAppserveDirectoryFileServerserveDirectoryWebAppLookupserveDirectoryEmbeddedserveDirectoryWithserveDirectory genericServe genericServeTgenericServeTWithContext genericServergenericServerT AuthHandler unAuthHandlerAuthServerData mkAuthHandler$fGenericAuthHandler Data.TypeableTypeRep%servant-0.19.1-JY9dyvYna3uB5d1U2lD6kBServant.API.ReqBodyReqBodyServant.API.CaptureCaptureNetwork.Wai.InternalRequestghc-prim GHC.TypesIOServant.API.NamedRoutes NamedRoutes GHC.GenericsRepServant.API.EmptyEmptyAPIServant.API.FragmentFragmentServant.API.Description DescriptionSummaryServant.API.QueryParam QueryFlagBool QueryParams GHC.TypeLitsText(http-api-data-0.5-AqjEGLlj3qoAdBIpOSyoCiWeb.Internal.HttpApiDataFromHttpApiData GHC.MaybeMaybeNothing CaptureAllServant.API.Alternative:<|>Servant.API.Sub:>GHC.BasereturnServant.API.UVerbUVerb ApplicativeServant.API.RawRaw-wai-app-static-3.1.7.4-4vkTNBQfvZHEBFTffwWU6pWaiAppStatic.Storage.FilesystemdefaultWebAppSettingsWaiAppStatic.TypesStaticSettingsdefaultFileServerSettingswebAppSettingsWithLookup%WaiAppStatic.Storage.Embedded.RuntimeembeddedSettingsNetwork.Wai.Application.Static staticAppData.Type.BoolIf ToHttpApiData toQueryParamtoHeader toUrlPiecetoEncodedUrlPieceparseQueryParam parseUrlPiece parseHeader(http-types-0.12.3-15jKboqV1ys4s9csJGbrJMNetwork.HTTP.Types.Version HttpVersion httpMinor httpMajorNetwork.HTTP.Types.Method StdMethodPATCHOPTIONSCONNECTTRACEDELETEPUTHEADGETPOST*network-uri-2.6.4.1-DXx94Tarxth8HOiU66mdO8 Network.URIURI uriFragmenturiQueryuriPath uriAuthority uriScheme Servant.LinksallFieldLinks' allFieldLinks fieldLink' fieldLink allLinks'allLinks safeLink'safeLinklinkURI'linkURI linkFragmentlinkQueryParams linkSegmentsLinkParam FlagParam SingleParamArrayElemParamLinkArrayElementStyleLinkArrayElementBracketLinkArrayElementPlainAsLinkMkLinkHasLinktoLinkServant.API.StreamStream StreamGet StreamPost StreamBody StreamBody'SourceIO ToSourceIO toSourceIO FromSourceIO fromSourceIO FramingRender framingRenderFramingUnrenderframingUnrender NoFramingNewlineFramingNetstringFramingServant.API.TypeLevel EndpointsIsElem'IsElemIsSubAPI AllIsElemIsInIsStrictSubAPIAllIsInMapSub AppendList IsSubListElemElemGoOrAndAtLeastOneFragmentFragmentUniqueServant.API.VerbsVerb NoContentVerbGetPostPutDeletePatch PostCreated PutCreated GetAccepted PostAcceptedDeleteAccepted PatchAccepted PutAcceptedGetNonAuthoritativePostNonAuthoritativeDeleteNonAuthoritativePatchNonAuthoritativePutNonAuthoritative GetNoContent PostNoContentDeleteNoContentPatchNoContent PutNoContentGetResetContentPostResetContentGetPartialContent ReflectMethod reflectMethodstatusOfStatusOf HasStatusStatuses WithStatusServant.API.UVerb.UnionUnionIsMemberUniqueServant.API.ResponseHeaderslookupResponseHeadernoHeader addHeaderHeadersgetHeadersHList getResponseResponseHeaderUndecodableHeaderHeader MissingHeaderHListHNilHConsBuildHeadersTobuildHeadersTo GetHeaders getHeaders AddHeaderHasResponseHeaderReqBody'Servant.API.RemoteHost RemoteHost QueryParam QueryParam'Servant.API.HeaderHeader'Servant.API.ModifiersRequiredOptionalLenientStrictServant.API.IsSecureIsSecureSecure NotSecureServant.API.Generic genericApi fromServant toServantGenericServant:- GenericMode ToServant ToServantApiAsApiGServantProductServant.API.Experimental.Auth AuthProtectServant.API.ContentTypesJSON PlainTextFormUrlEncoded OctetStreamAccept contentType contentTypes MimeRender mimeRender MimeUnrender mimeUnrendermimeUnrenderWithType NoContentCapture'Servant.API.BasicAuth BasicAuth BasicAuthDatabasicAuthPasswordbasicAuthUsername$vault-0.3.1.5-7vZCTPVb1VO3GlS3OgA8adData.Vault.LazyVault+singleton-bool-0.1.6-570mbJFPg7nE3nQ4tAPS7yData.Singletons.BoolSBoolIsboolSBoolSFalseSTrueinject