!      !"#$%&'()*+,-./0123456789:;<=> ? @ A B C D E F GHIJ K LMN O PQRSTUVW X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~           !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe1345ST*servant=Union of two APIs, first takes precedence in case of overlap.Example::{8type MyApi = "books" :> Get '[JSON] [Book] -- GET /booksM :<|> "books" :> ReqBody '[JSON] Book :> Post '[JSON] () -- POST /books:}*+*+*3+3Safe,-1F"[4servant=A simple datatype to hold data required to decorate a request8servantCombinator for  -https://tools.ietf.org/html/rfc2617#section-2Basic Access Authentication.6IMPORTANT*: Only use Basic Auth over HTTPS! Credentials are not hashed or encrypted. Note also that because the same credentials are sent on every request, Basic Auth is not as secure as some alternatives. Further, the implementation in servant-server does not protect against some types of timing attacks.QIn Basic Auth, username and password are base64-encoded and transmitted via the  AuthorizationF header. Handshakes are not required, making it relatively efficient.4576884576Safe,-1F)T9servantICapture all remaining values from the request path under a certain type a.Example: -- GET /src/*Jtype MyAPI = "src" :> CaptureAll "segments" Text :> Get '[JSON] SourceFile:servant;) which can be modified. For example with  Description.;servant;Capture a value from the request path under a certain type a.Example:-- GET /books/:isbn?type MyApi = "books" :> Capture "isbn" Text :> Get '[JSON] Book9:;;:9 None+,-16;=>?FNSTVTR<servant*A type for responses without content-body.GservantYInstantiate this class to register a way of deserializing a type based on the request's  Content-Type header.)import Network.HTTP.Media hiding (Accept)2import qualified Data.ByteString.Lazy.Char8 as BSC)data MyContentType = MyContentType String:{#instance Accept MyContentType whereE contentType _ = "example" // "prs.me.mine" /: ("charset", "utf-8"):}:{5instance Read a => MimeUnrender MyContentType a where- mimeUnrender _ bs = case BSC.take 12 bs ofC "MyContentType" -> return . read . BSC.unpack $ BSC.drop 12 bs8 _ -> Left "didn't start with the magic incantation":}Ftype MyAPI = "path" :> ReqBody '[MyContentType] Int :> Get '[JSON] IntIservant"Variant which is given the actual  provided by the other party.8In the most cases you don't want to branch based on the . See  3https://github.com/haskell-servant/servant/pull/552pr552 for a motivating example.LservantMInstantiate this class to register a way of serializing a type based on the Accept header.Example: data MyContentType instance Accept MyContentType where contentType _ = "example" // "prs.me.mine" /: ("charset", "utf-8") instance Show a => MimeRender MyContentType a where mimeRender _ val = pack ("This is MINE! " ++ show val) type MyAPI = "path" :> Get '[MyContentType] IntPservant Instances of P> represent mimetypes. They are used for matching against the Accept2 HTTP header of the request, and for setting the  Content-Type header of the responseExample:&import Network.HTTP.Media ((//), (/:)) data HTML:{instance Accept HTML where; contentType _ = "text" // "html" /: ("charset", "utf-8"):}XservantLike @ but allows all JSON values instead of just objects and arrays.;Will handle trailing whitespace, but not trailing junk. ie.-eitherDecodeLenient "1 " :: Either String IntRight 11eitherDecodeLenient "1 junk" :: Either String Int1Left "trailing junk after valid JSON: endOfInput"Yservant application/octet-streamZservant text/plain;charset=utf-8[servant !application/x-www-form-urlencoded\servant application/json]servant^servant id_servant BC.pack`servant fromStrict . TextS.encodeUtf8aservantbservanturlEncodeAsForm Note that the *mimeUnrender p (mimeRender p x) == Right x> law only holds if every element of x is non-null (i.e., not ("", ""))cservantdservant Right . toStricteservant  Right . idfservant Right . BC.unpackgservant (left show . TextS.decodeUtf8' . toStricthservant left show . TextL.decodeUtf8'iservanturlDecodeAsForm Note that the *mimeUnrender p (mimeRender p x) == Right x> law only holds if every element of x is non-null (i.e., not ("", ""))jservant eitherDecode<=>?@ABCDEFGHIJKLMNOPQRSTUVWXVUTSPQRLMGHI<=NOJKDEFBC@A>?XW Safe ,-1<FSTVd ~servantImplementation of .servantUFold modifier list to decide whether argument should be parsed strictly or leniently.:kind! FoldDescription '[]FoldDescription '[] :: Symbol= ""A:kind! FoldDescription '[Required, Description "foobar", Lenient]DFoldDescription '[Required, Description "foobar", Lenient] :: Symbol = "foobar"servant/Add more verbose description for (part of) API.Example::{type MyApi = Description? "This comment is visible in multiple Servant interpretations \( \and can be really long if necessary. \, \Haskell multiline support is not perfect \ \but it's still very readable.":> Get '[JSON] Book:}servant&Add a short summary for (part of) API.Example:^type MyApi = Summary "Get book by ISBN." :> "books" :> Capture "isbn" Text :> Get '[JSON] Bookservant&Reflect description to the term level.NreflectDescription (Proxy :: Proxy '[Required, Description "foobar", Lenient])"foobar"~~ Safe1gservantVAn empty API: one which serves nothing. Morally speaking, this should be the unit of :<|>=. Implementors of interpretations of API types should treat " as close to the unit as possible. Safe,-1FjservantgA generalized Authentication combinator. Use this if you have a non-standard authentication technique.5NOTE: THIS API IS EXPERIMENTAL AND SUBJECT TO CHANGE.Safe+<FSTuservant_A type that specifies that an API record contains an API definition. Only useful at type-level.servant,Turns a generic product type into a tree of * combinators.servantJA class with a type family that applies an appropriate type family to the api parameter. For example,  will leave api untouched, while  AsServerT m will produce ServerT api m.servant"A constraint alias, for work with mode and routes.servantSee , but at value-level.servant Inverse of .This can be used to turn  generated. values such as client functions into records.1You may need to provide a type signature for the output type (your record type).servantGet a  of an API type.  0Safev  Safe16servant-Was this request made over an SSL connection?UNote that this value will not tell you if the client originally made this request over SSL, but rather whether the current connection is SSL. The distinction lies with reverse proxies. In many cases, the client will connect to a load balancer over SSL, but connect to the WAI handler without SSL. In such a case, the handlers would get =, but from a user perspective, there is a secure connection.servant1the connection to the server is secure (HTTPS)servant4the connection to the server is not secure (HTTP)None -<FSTV servantHelper type alias.By default argument is  and .,  ! a,  !   a,  !  a,  !  (  a)servantHelper type alias. ! a !  aservantImplementation of .servantUFold modifier list to decide whether argument should be parsed strictly or leniently.:kind! FoldLenient '[]FoldLenient '[] :: Bool= 'Falseservant&Strictly parsed argument. Not wrapped.servant?Leniently parsed argument, i.e. parsing never fail. Wrapped in  .servantImplementation of .servant:Fold modifier list to decide whether argument is required.8:kind! FoldRequired '[Required, Description "something"]9FoldRequired '[Required, Description "something"] :: Bool= 'True):kind! FoldRequired '[Required, Optional]*FoldRequired '[Required, Optional] :: Bool= 'False:kind! FoldRequired '[]FoldRequired '[] :: Bool= 'FalseservantOptional argument. Wrapped in .servantRequired argument. Not wrapped.servantFold a RequiredAgument into a valueservantUnfold a value into a .servantUnfold a value into a .servantservantservanterror when argument is requiredservant&error when argument is strictly parsedservantvalueservanterror when argument is requiredservant&error when argument is strictly parsedservantvalue None,-1Fservant4Extract the given header's value as a value of type a0. I.e. header sent by client, parsed by server.Example:2newtype Referer = Referer Text deriving (Eq, Show)-- GET /view-my-refererNtype MyApi = "view-my-referer" :> Header "from" Referer :> Get '[JSON] RefererNone,-1FSTservant]Lookup a potentially value-less query string parameter with boolean semantics. If the param sym] is there without any value, or if it's there with value "true" or "1", it's interpreted as ". Otherwise, it's interpreted as .Example:-- /books?publishedCtype MyApi = "books" :> QueryFlag "published" :> Get '[JSON] [Book]servant$Lookup the values associated to the symB query string parameter and try to extract it as a value of type [a]K. This is typically meant to support query string parameters of the form param[]=val1&param[]=val2< and so on. Note that servant doesn't actually require the [],s and will fetch the values just fine with param=val1&param=val2, too.Example:5-- /books?authors[]=<author1>&authors[]=<author2>&...Htype MyApi = "books" :> QueryParams "authors" Text :> Get '[JSON] [Book]servant which can be , , or modified otherwise.servant#Lookup the value associated to the symB query string parameter and try to extract it as a value of type a.Example:-- /books?author=<author name>Ftype MyApi = "books" :> QueryParam "author" Text :> Get '[JSON] [Book]Safe1=servant&Endpoint for plugging in your own Wai  Applications. The given  ApplicationY will get the request as received by the server, potentially with a modified (stripped) pathInfo if the  Application is being routed with .:In addition to just letting you plug in your existing WAI  Applications, this can also be used with  ghttps://hackage.haskell.org/package/servant-server/docs/Servant-Utils-StaticFiles.html#v:serveDirectoryserveDirectoryK to serve static files stored in a particular directory on your filesystemSafe1servantRProvides access to the host or IP address from which the HTTP request was sent.None,-1F servantNote:  is always .servant,Extract the request body as a value of type a.Example:-- POST /booksAtype MyApi = "books" :> ReqBody '[JSON] Book :> Post '[JSON] BookNone&',-13;<=>?AFSTV servantAuxiliary class for  ( hs a) instanceservantAuxiliary class for  ( hs) instanceservantNote: if there are multiple occurences of a header in the argument, the values are interspersed with commas before deserialization (see  <http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2RFC2616 Sec 4.2)servantXResponse Header objects. You should never need to construct one directly. Instead, use .servantThe underlying value of a servantHList of headers.servant addHeader` adds a header to a response. Note that it changes the type of the value in the following ways: .A simple value is wrapped in "Headers '[hdr]":Mlet example1 = addHeader 5 "hi" :: Headers '[Header "someheader" Int] String;getHeaders example1[("someheader","5")] YA value that already has a header has its new header *prepended* to the existing list:Mlet example1 = addHeader 5 "hi" :: Headers '[Header "someheader" Int] String;flet example2 = addHeader True example1 :: Headers '[Header "1st" Bool, Header "someheader" Int] StringgetHeaders example2#[("1st","true"),("someheader","5")]Note that while in your handlers type annotations are not required, since the type can be inferred from the API type, in other cases you may find yourself needing to add annotations.servant,Deliberately do not add a header to a value.Ilet example1 = noHeader "hi" :: Headers '[Header "someheader" Int] StringgetHeaders example1[]servant This instance is an optimisationservant3N.B.: The same header can't be added multiple timesSafe,-16;=>?AFNQV6 servant2The netstring framing strategy as defined by djb: $http://cr.yp.to/proto/netstrings.txtservantA simple framing strategy that has no header or termination, and inserts a newline character between each frame. This assumes that it is used with a Content-Type that encodes without newlines (e.g. JSON).servantA framing strategy that does not do any framing at all, it just passes the input data This will be used most of the time with binary data, such as filesservantWThe FramingUnrender class provides the logic for parsing a framing strategy. The outer ByteStringParser` strips the header from a stream of bytes, and yields a parser that can handle the remainder, stepwise. Each frame may be a ByteString, or a String indicating the error state for that frame. Such states are per-frame, so that protocols that can resume after errors are able to do so. Eventually this returns an empty ByteString to indicate termination.servantA type of parser that can never fail, and has different parsing strategies (incremental, or EOF) depending if more input can be sent. The incremental parser should return | if it would like to be sent a longer ByteString. If it returns a value, it also returns the remainder following that value.servant(The bracketing strategy generates things to precede and follow the content, as with netstrings. The intersperse strategy inserts seperators between things, as with newline framing. Finally, the general strategy performs an arbitrary rewrite on the content, to allow escaping rules and such.servantThe FramingRender class provides the logic for emitting a framing strategy. The strategy emits a header, followed by boundary-delimited data, and finally a termination character. For many strategies, some of these will just be empty bytestrings.servantBuildFromStream is intended to be implemented for types such as Conduit, Pipe, etc. By implementing this class, all such streaming abstractions can be used directly on the client side for talking to streaming endpoints.servantKClients reading from streaming endpoints can be implemented as producing a  ResultStream that captures the setup, takedown, and incremental logic for a read, being an IO continuation that takes a producer of Just either values or errors that terminates with a Nothing.servantToStreamGenerator is intended to be implemented for types such as Conduit, Pipe, etc. By implementing this class, all such streaming abstractions can be used directly as endpoints.servant3Stream endpoints may be implemented as producing a StreamGenerator -- a function that itself takes two emit functions -- the first to be used on the first value the stream emits, and the second to be used on all subsequent values (to allow interspersed framing strategies such as comma separation).servantA Stream endpoint for a given method emits a stream of encoded values at a given Content-Type, delimited by a framing strategy. Stream endpoints always return response code 200 on success. Type synonyms are provided for standard methods.Safe,1FST'servant7The contained API (second argument) can be found under  ("/" ++ path)" (path being the first argument).Example:-- GET /hello/world'-- returning a JSON encoded World value4type MyApi = "hello" :> "world" :> Get '[JSON] World4Noney))Safe,-16Fservant with 206 status code.servant with 205 status code.servant with 205 status code.servant with 205 status code.servant with 205 status code.servant with 205 status code.servant with 204 status code.servant with 204 status code. servant with 204 status code. servant with 204 status code. servant with 204 status code. servant with 203 status code. servant with 203 status code.servant with 203 status code.servant with 203 status code.servant with 203 status code.servant with 202 status code.servant with 202 status code.servant with 202 status code.servant with 202 status code.servant with 202 status code.servant with 201 status code.servant with 200 status code.servant with 200 status code.servant with 200 status code.servant with 200 status code.servant with 200 status code.servantVerb is a general type for representing HTTP verbs (a.k.a. methods). For convenience, type synonyms for each verb with a 200 response code are provided, but you are free to define your own:;type Post204 contentTypes a = Verb 'POST 204 contentTypes a(     (     None +,->?FSTH 'servantHIf both a or b produce an empty constraint, produce an empty constraint.(servantJIf either a or b produce an empty constraint, produce an empty constraint.*servant+Check that a value is an element of a list:,ok (Proxy :: Proxy (Elem Bool '[Int, Bool]))OK.ok (Proxy :: Proxy (Elem String '[Int, Bool]))...... [Char]...'[Int, Bool......,servantAppend two type-level lists.-servantApply (e :>) to every API in xs..servantCheck that every element of xs is an endpoint of api (using 0).Aok (Proxy :: Proxy (AllIsIn (Endpoints SampleAPI) SampleAPI)) OK/servantCheck whether sub is a sub API of api.Like 2 , but uses 0 rather than 3.0servantClosed type family, check if endpoint is exactly within api.Aok (Proxy :: Proxy (IsIn ("hello" :> Get '[JSON] Int) SampleAPI))OKUnlike 3!, this requires an *exact* match.Qok (Proxy :: Proxy (IsIn (Get '[JSON] Int) (Header "h" Bool :> Get '[JSON] Int)))...... Could not deduce......1servantCheck that every element of xs is an endpoint of api (using 3).2servantCheck whether sub is a sub-API of api.Iok (Proxy :: Proxy (IsSubAPI SampleAPI (SampleAPI :<|> Get '[JSON] Int)))OKIok (Proxy :: Proxy (IsSubAPI (SampleAPI :<|> Get '[JSON] Int) SampleAPI))...... Could not deduce...... This uses IsElem0 for checking; thus the note there applies here.3servantClosed type family, check if endpoint is within api. Uses 4" if it exhausts all other options.Cok (Proxy :: Proxy (IsElem ("hello" :> Get '[JSON] Int) SampleAPI))OKAok (Proxy :: Proxy (IsElem ("bye" :> Get '[JSON] Int) SampleAPI))...... Could not deduce......eAn endpoint is considered within an api even if it is missing combinators that don't affect the URL:Sok (Proxy :: Proxy (IsElem (Get '[JSON] Int) (Header "h" Bool :> Get '[JSON] Int)))OKXok (Proxy :: Proxy (IsElem (Get '[JSON] Int) (ReqBody '[JSON] Bool :> Get '[JSON] Int)))OKN.B.:*  IsElem a bH can be seen as capturing the notion of whether the URL represented by a$ would match the URL represented by b*, *not* whether a request represented by a matches the endpoints serving b (for the latter, use 0).4servantYou may use this type family to tell the type checker that your custom type may be skipped as part of a link. This is useful for things like H that are optional in a URI and do not affect them if they are omitted.data CustomThing7type instance IsElem' e (CustomThing :> s) = IsElem e s Note that 30 is called, which will mutually recurse back to 4) if it exhausts all other options again.Once you have written a HasLink instance for  CustomThing you are ready to go.5servant%Flatten API into a list of endpoints.Refl :: Endpoints SampleAPI :~: '["hello" :> Verb 'GET 200 '[JSON] Int, "bye" :> (Capture "name" String :> Verb 'POST 200 '[JSON, PlainText] Bool)]Refl'()*+,-./012345543210/.-,+*)('Safe-FP6servant6V names a specific tagged context to use for the combinators in the API. (See also in servant-server, Servant.Server.Context.) For example: ntype UseNamedContextAPI = WithNamedContext "myContext" '[String] ( ReqBody '[JSON] Int :> Get '[JSON] Int) Both the ReqBody and Get combinators will use the 6- with type tag "myContext" as their context.Contexts are only relevant for servant-server.'For more information, see the tutorial.66None+,-;<=>?AFSTVA7servant#Construct a toLink for an endpoint.:servantAA type that specifies that an API record contains a set of links.;servant#How to encode array query elements.<servant foo[]=1&foo[]=2=servant  foo=1&foo=2>servantQuery parameter.Bservant6A safe link datatype. The only way of constructing a B is using G, which means any B/ is guaranteed to be part of the mentioned API.Eservant Transform B into #.)type API = "something" :> Get '[JSON] Int<linkURI $ safeLink (Proxy :: Proxy API) (Proxy :: Proxy API) something:type API = "sum" :> QueryParams "x" Int :> Get '[JSON] IntFlinkURI $ safeLink (Proxy :: Proxy API) (Proxy :: Proxy API) [1, 2, 3]sum?x[]=1&x[]=2&x[]=3'type API = "foo/bar" :> Get '[JSON] Int<linkURI $ safeLink (Proxy :: Proxy API) (Proxy :: Proxy API) foo%2FbarBtype SomeRoute = "abc" :> Capture "email" String :> Put '[JSON] ()(let someRoute = Proxy :: Proxy SomeRoute/safeLink someRoute someRoute "test@example.com"BLink {_segments = ["abc","test%40example.com"], _queryParams = []}9linkURI $ safeLink someRoute someRoute "test@example.com"abc/test%40example.comFservant Configurable E.:type API = "sum" :> QueryParams "x" Int :> Get '[JSON] Int_linkURI' LinkArrayElementBracket $ safeLink (Proxy :: Proxy API) (Proxy :: Proxy API) [1, 2, 3]sum?x[]=1&x[]=2&x[]=3]linkURI' LinkArrayElementPlain $ safeLink (Proxy :: Proxy API) (Proxy :: Proxy API) [1, 2, 3]sum?x=1&x=2&x=3Gservant@Create a valid (by construction) relative URI with query params.%This function will only typecheck if endpoint is part of the API apiHservant More general G.IservantCreate all links in an API.Note that the apiI type must be restricted to the endpoints that have valid links to them.rtype API = "foo" :> Capture "name" Text :> Get '[JSON] Text :<|> "bar" :> Capture "name" Int :> Get '[JSON] Double8let fooLink :<|> barLink = allLinks (Proxy :: Proxy API) :t fooLinkfooLink :: Text -> Link :t barLinkbarLink :: Int -> Link4Note: nested APIs don't work well with this approach~:kind! MkLink (Capture "nest" Char :> (Capture "x" Int :> Get '[JSON] Int :<|> Capture "y" Double :> Get '[JSON] Double)) Link|MkLink (Capture "nest" Char :> (Capture "x" Int :> Get '[JSON] Int :<|> Capture "y" Double :> Get '[JSON] Double)) Link :: *-= Char -> (Int -> Link) :<|> (Double -> Link)Jservant More general I. See H.KservantXGiven an API record field, create a link for that route. Only the field's type is used. data Record route = Record { _get :: route :- Capture "id" Int :> Get '[JSON] String , _put :: route :- ReqBody '[JSON] Int :> Put '[JSON] Bool } deriving ($) getLink :: Int -> Link getLink = K _get LservantMore general version of KMservantGet all links as a record.NservantMore general version of M.servantHelper for implemneting 9/ for combinators not affecting link structure.9servant+The API endpoint you would like to point toGservant-The whole API that this endpoint is a part ofservant+The API endpoint you would like to point toHservant-The whole API that this endpoint is a part ofservant+The API endpoint you would like to point to.#"! '()*+,-./012345789:;<=>?@ABCDEFGHIJKLMNGHIJ#"! :KLMN789BEF;<=>?@ACDNone  #"! &%$(')*+456789:;<=GHILMPQRSTUV     346789BG*+9:; )6     45678<=GHILMPQRSTUV #"! 34789BG&%$('None-ST*opqrsqprosNone;=>?AFQSTV8 uservantMap the leafs of an API type.vservant Helper type family to state the t symmetry.wservantLike .{servantLog the contents of P with the function provided as the first argument, and return the value of the WriterT computation|servantLike {, but for lazy WriterT.}servantLike mmorph's .~servantLike mmorph's .servantLike mmorph's .servantLike mmorph's .tuvwxyz{|}~tuvwxyz{|}~None.#"! '()*+,-./012345789:;<=>?@ABCDEFGHIJKLMN !" !# $%&'(&')&'*&'+&',&'-&'.&'/&'012312412512516716816916:16;16<16=16>16?16@ABCABDABEFGHFGIFGJFGKFGLFGMFGMNOPNOQNORNOSNOTUVWXXYZ[\]^_`aabcdefg h h i j k l m n o p q r s t u v w x y y z { | } ~                   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~?    %servant-0.14.1-EgbVaicHQEdCgqTzWc4SOjServant.API.Generic Servant.APIServant.API.HttpVersionServant.API.VerbsServant.Utils.EnterServant.API.VaultServant.API.AlternativeServant.API.BasicAuthServant.API.ContentTypesServant.API.DescriptionServant.API.EmptyServant.API.Experimental.AuthServant.API.IsSecureServant.API.ModifiersServant.API.RemoteHostServant.API.ResponseHeadersServant.API.StreamServant.API.TypeLevelServant.API.WithNamedContext Servant.Links*Servant.API.Internal.Test.ComprehensiveAPIServant.API.Capture Data.Aeson eitherDecodeServant.API.HeaderServant.API.QueryParamServant.API.RawServant.API.Sub:>Servant.API.ReqBodyServant.Utils.Linksbase GHC.GenericsGenericRepData.Type.BoolIf,http-api-data-0.3.8.1-8JbdzYMkghw4VmWZ8qnnFMWeb.Internal.HttpApiData toQueryParamtoHeadertoEncodedUrlPiece toUrlPiece ToHttpApiDataparseQueryParam parseHeader parseUrlPieceFromHttpApiData(http-types-0.12.1-CVeYXehbrw3Br6YeJckOG5Network.HTTP.Types.Version httpMinor httpMajor HttpVersionNetwork.HTTP.Types.MethodPATCHOPTIONSCONNECTTRACEDELETEPUTHEADPOSTGET StdMethod1natural-transformation-0.4-H812UKihNmSBjnMSucJuXMControl.Natural$$NT:~>*network-uri-2.6.1.0-AstEwZoXrlUJQq4VkxaVo9 Network.URI uriFragmenturiQueryuriPath uriAuthority uriSchemeURI+singleton-bool-0.1.4-8EznQE6dMi2H7lit14Cx2CData.Singletons.BoolSFalseSTrueSBoolsboolSBoolI$vault-0.3.1.1-2GquhY3BX83KRwXf3C8PlYData.Vault.LazyVault:<|> $fMonoid:<|>$fSemigroup:<|>$fEq:<|> $fShow:<|> $fFunctor:<|>$fTraversable:<|>$fFoldable:<|> $fBounded:<|> BasicAuthDatabasicAuthUsernamebasicAuthPassword BasicAuth CaptureAllCapture'Capture NoContentAllMimeUnrenderallMimeUnrender AllMimeRender allMimeRenderAllMimeallMime AllCTUnrendercanHandleCTypeH handleCTypeH MimeUnrender mimeUnrendermimeUnrenderWithType AllCTRender handleAcceptH MimeRender mimeRender AcceptHeaderAccept contentType contentTypes OctetStreamFormUrlEncoded PlainTextJSONcanHandleAcceptHeitherDecodeLenient$fAcceptTYPEOctetStream$fAcceptTYPEPlainText$fAcceptTYPEFormUrlEncoded$fAcceptTYPEJSON%$fMimeRenderTYPEOctetStreamByteString&$fMimeRenderTYPEOctetStreamByteString0$fMimeRenderTYPEPlainText[]$fMimeRenderTYPEPlainTextText$fMimeRenderTYPEPlainTextText0$fMimeRenderTYPEFormUrlEncodeda$fMimeRenderTYPEJSONa'$fMimeUnrenderTYPEOctetStreamByteString($fMimeUnrenderTYPEOctetStreamByteString0$fMimeUnrenderTYPEPlainText[]$fMimeUnrenderTYPEPlainTextText $fMimeUnrenderTYPEPlainTextText0!$fMimeUnrenderTYPEFormUrlEncodeda$fMimeUnrenderTYPEJSONa $fAllMime: $fAllMime[]$fAllCTRender[]()$fAllMimeRender:a$fAllMimeRender:a0$fAllCTRender:a$fAllMimeUnrender:a$fAllMimeUnrender[]a$fAllCTUnrenderctypsa$fAllMimeRender:NoContent$fAllMimeRender:NoContent0$fEqAcceptHeader$fShowAcceptHeader$fReadAcceptHeader$fGenericAcceptHeader$fShowNoContent $fEqNoContent$fReadNoContent$fGenericNoContentFoldDescription'FoldDescription DescriptionSummaryreflectDescriptionEmptyAPI $fEqEmptyAPI$fShowEmptyAPI$fBoundedEmptyAPI$fEnumEmptyAPI AuthProtectGServantProductAsApi ToServantApi ToServant GenericMode:-GenericServant toServant fromServant genericApi$fGenericModeAsApi$fGServantProductK1$fGServantProduct:*:$fGServantProductM1IsSecureSecure NotSecure $fEqIsSecure$fShowIsSecure$fReadIsSecure$fGenericIsSecure $fOrdIsSecureRequestArgumentRequiredArgument FoldLenient' FoldLenientStrictLenient FoldRequired' FoldRequiredOptionalRequiredfoldRequiredArgumentunfoldRequiredArgumentunfoldRequestArgumentHeader'Header QueryFlag QueryParams QueryParam' QueryParamRaw RemoteHostReqBody'ReqBody AddHeader GetHeaders getHeadersBuildHeadersTobuildHeadersTo HeaderValMapHListHNilHConsResponseHeader MissingHeaderUndecodableHeaderHeaders getResponsegetHeadersHList addHeadernoHeader$fBuildHeadersTo:$fBuildHeadersTo[]$fGetHeadersFromHList:$fGetHeadersFromHList[]$fGetHeadersHList$fGetHeaders':$fGetHeaders'[]$fGetHeadersHeaders$fAddHeaderhvanew$fAddHeaderhvHeadersHeaders$fEqResponseHeader$fShowResponseHeader$fFunctorResponseHeader$fFunctorHeadersNetstringFramingNewlineFraming NoFramingFramingUnrenderunrenderFramesByteStringParserparseIncrementalparseEOFBoundaryStrategyBoundaryStrategyBracketBoundaryStrategyIntersperseBoundaryStrategyGeneral FramingRenderheaderboundarytrailerBuildFromStreambuildFromStream ResultStreamToStreamGeneratortoStreamGeneratorStreamGeneratorgetStreamGenerator StreamPost StreamGetStream#$fToStreamGeneratorStreamGeneratora$fBuildFromStreamaResultStream $fFramingUnrenderTYPEkNoFraminga$fFramingRenderTYPEkNoFraminga%$fFramingUnrenderTYPEkNewlineFraminga#$fFramingRenderTYPEkNewlineFraminga'$fFramingUnrenderTYPEkNetstringFraminga%$fFramingRenderTYPEkNetstringFraminga$fGenericStream ReflectMethod reflectMethodGetPartialContentPutResetContentPatchResetContentDeleteResetContentPostResetContentGetResetContent PutNoContentPatchNoContentDeleteNoContent PostNoContent GetNoContentPutNonAuthoritativePatchNonAuthoritativeDeleteNonAuthoritativePostNonAuthoritativeGetNonAuthoritative PutAccepted PatchAcceptedDeleteAccepted PostAccepted GetAccepted PostCreatedPatchDeletePutPostGetVerb$fReflectMethodStdMethodCONNECT$fReflectMethodStdMethodTRACE$fReflectMethodStdMethodOPTIONS$fReflectMethodStdMethodHEAD$fReflectMethodStdMethodPATCH$fReflectMethodStdMethodDELETE$fReflectMethodStdMethodPUT$fReflectMethodStdMethodPOST$fReflectMethodStdMethodGET $fGenericVerbAndOrElemGoElem IsSubList AppendListMapSubAllIsInIsStrictSubAPIIsIn AllIsElemIsSubAPIIsElemIsElem' EndpointsWithNamedContextHasLinkMkLinktoLinkAsLinkLinkArrayElementStyleLinkArrayElementBracketLinkArrayElementPlainParam SingleParamArrayElemParam FlagParamLink linkSegmentslinkQueryParamslinkURIlinkURI'safeLink safeLink'allLinks allLinks' fieldLink fieldLink' allFieldLinksallFieldLinks' $fShowEscaped$fToHttpApiDataLink$fHasLinkTYPE:>$fHasLinkTYPEStream$fHasLinkTYPERaw$fHasLinkTYPEVerb$fHasLinkTYPEEmptyAPI$fHasLinkTYPE:>0$fHasLinkTYPE:>1$fHasLinkTYPEWithNamedContext$fHasLinkTYPE:>2$fHasLinkTYPE:>3$fHasLinkTYPE:>4$fHasLinkTYPE:>5$fHasLinkTYPE:>6$fHasLinkTYPE:>7$fHasLinkTYPE:>8$fHasLinkTYPE:>9$fHasLinkTYPE:>10$fHasLinkTYPE:<|>$fHasLinkTYPE:>11$fHasLinkTYPE:>12$fHasLinkTYPE:>13$fHasLinkTYPE:>14$fGenericModeAsLink $fShowParam $fShowLink$fEqLinkArrayElementStyle$fOrdLinkArrayElementStyle$fShowLinkArrayElementStyle$fEnumLinkArrayElementStyle$fBoundedLinkArrayElementStyleComprehensiveAPIWithoutRawComprehensiveAPIcomprehensiveAPIcomprehensiveAPIWithoutRawEnterenterEnteredliftNat runReaderTNatevalStateTLNatevalStateTSNatlogWriterTSNatlogWriterTLNathoistNatembedNat squashNat generalizeNat $fEntermmnn$fEnterTaggedmnTagged$fEnter(->)mn(->)$fEnter:<|>m1n1:<|>)http-media-0.7.1.2-1UjzpOxjp3a9hJsLfTdIsR%Network.HTTP.Media.MediaType.Internal MediaTypebytestring-0.10.8.2Data.ByteString.Lazy fromStrict text-1.2.3.0Data.Text.Lazy.Encoding encodeUtf8$aeson-1.4.0.0-LIOMjdhUbDoEPhbHMMZ6tyencode Data.ProxyProxy Data.EitherEitherData.Text.InternalTextGHC.BaseMaybeghc-prim GHC.TypesTrueFalse GetHeaders'GetHeadersFromHListaddOptionalHeaderNothing simpleToLinktransformers-0.5.5.0Control.Monad.Trans.Classlift!Control.Monad.Trans.Writer.StrictWriterT#mmorph-1.1.2-7obnGkZKKLM4PjmQqTaRyYControl.Monad.Morphhoistembedsquash generalize