úÎĮæĀM„      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ None025<=DIRT @The request body. Currently only lazy ByteStrings are supported.0A type representing possible errors in a request2Note that this type substantially changed in 0.12.%The server returned an error response2The body could not be decoded at the expected type1The content-type of the response is not supported"The content-type header is invalid:There was a connection error, and no response was received 9Set body and media type of the request being constructed.2The body is set to the given bytestring using the  constructor. 9Set body and media type of the request being constructed.  param name param value     None :<=DRT.How to make a request.-./012-./012-./012-./012None,69:;<=DQR6gMatch client structure with client functions, expanding left-nested API clients in the same structure.8mMatch client structure with client functions, regarding left-nested API clients as separate data structures.:TThis class allows us to match client structure with client functions produced with client# without explicit pattern-matching.The client structure needs a „ instance.Example: ĸˆtype API = "foo" :> Capture "x" Int :> Get '[JSON] Int :<|> "bar" :> QueryParam "a" Char :> QueryParam "b" String :> Post '[JSON] [Int] :<|> Capture "nested" Int :> NestedAPI type NestedAPI = Get '[JSON] String :<|> "baz" :> QueryParam "c" Char :> Post '[JSON] () data APIClient = APIClient { getFoo :: Int -> ClientM Int , postBar :: Maybe Char -> Maybe String -> ClientM [Int] , mkNestedClient :: Int -> NestedClient } deriving GHC.Generic instance Generics.SOP.Generic APIClient instance (Client API ~ client) => ClientLike client APIClient data NestedClient = NestedClient { getString :: ClientM String , postBaz :: Maybe Char -> ClientM () } deriving GHC.Generic instance Generics.SOP.Generic NestedClient instance (Client NestedAPI ~ client) => ClientLike client NestedClient mkAPIClient :: APIClient mkAPIClient = mkClient (client (Proxy :: Proxy API))2By default, left-nested alternatives are expanded: ĸ2type API1 = "foo" :> Capture "x" Int :> Get '[JSON] Int :<|> "bar" :> QueryParam "a" Char :> Post '[JSON] String type API2 = "baz" :> QueryParam "c" Char :> Post '[JSON] () type API = API1 :<|> API2 data APIClient = APIClient { getFoo :: Int -> ClientM Int , postBar :: Maybe Char -> ClientM String , postBaz :: Maybe Char -> ClientM () } deriving GHC.Generic instance Generics.SOP.Generic APIClient instance (Client API ~ client) => ClientLike client APIClient mkAPIClient :: APIClient mkAPIClient = mkClient (client (Proxy :: Proxy API))!If you want to define client for API1, as a separate data structure, you can use =: ĸHdata APIClient1 = APIClient1 { getFoo :: Int -> ClientM Int , postBar :: Maybe Char -> ClientM String } deriving GHC.Generic instance Generics.SOP.Generic APIClient1 instance (Client API1 ~ client) => ClientLike client APIClient1 data APIClient = APIClient { mkAPIClient1 :: APIClient1 , postBaz :: Maybe Char -> ClientM () } deriving GHC.Generic instance Generics.SOP.Generic APIClient instance (Client API ~ client) => ClientLike client APIClient where mkClient = genericMkClientP mkAPIClient :: APIClient mkAPIClient = mkClient (client (Proxy :: Proxy API))<XGenerate client structure from client type, expanding left-nested API (done by default).=jGenerate client structure from client type, regarding left-nested API clients as separate data structures.3456789:;<=>?@ABCD 3456789:;<=:;;D89CB67A@534?><=3456789:;;<=>?@ABCDNone9DRE1Authenticate a request using Basic AuthenticationEEEESafe$05HkSimple data type to represent the target of HTTP requests for servant's automatically-generated clients.JURI scheme to useKhost (eg "haskell.org")L port (eg 80)M path (eg "ab/c")NURI scheme to useOhttp://Phttps://FGHIJKLMNOPQRST FGHIJKLMNOPQRNOPHIJKLMTQFGSRFGHIJKLMNOPQRSTNone9DR]hFor better type inference and to avoid usage of a data family, we newtype wrap the combination of some `8 and a function to add authentication data to a request4NOTE: THIS API IS EXPERIMENTAL AND SUBJECT TO CHANGE`šFor a resource protected by authentication (e.g. AuthProtect), we need to provide the client with some data used to add authentication data to a request4NOTE: THIS API IS EXPERIMENTAL AND SUBJECT TO CHANGEa>Handy helper to avoid wrapping datatypes in tuples everywhere.4NOTE: THIS API IS EXPERIMENTAL AND SUBJECT TO CHANGE]^_`a]^_`a`]^_a]^_`aNone+,-9:;<=DQRTb6Singleton type representing a client for an empty API.d^This class lets us define how each API combinator influences the creation of an HTTP request.)Unless you are writing a new backend for servant-client-core\ or new combinators that you want to support client-generation, you can ignore this class.ggJ allows you to produce operations to query an API from a client within a - monad. ĸTtype MyApi = "books" :> Get '[JSON] [Book] -- GET /books :<|> "books" :> ReqBody '[JSON] Book :> Post '[JSON] Book -- POST /books myApi :: Proxy MyApi myApi = Proxy clientM :: Proxy ClientM clientM = Proxy getAllBooks :: ClientM [Book] postNewBook :: Book -> ClientM Book (getAllBooks :<|> postNewBook) = myApi `clientIn` clientMn"Make the querying function append path to the request path.o If you use a …š in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of the type specified by your …g. That function will take care of encoding this argument as JSON and of using it as the request body.(All you need is for your type to have a ToJSON instance.Example: Ũtype MyApi = "books" :> ReqBody '[JSON] Book :> Post '[JSON] Book myApi :: Proxy MyApi myApi = Proxy addBook :: Book -> ClientM Book addBook = client myApi -- then you can just use "addBook" to query that endpointpPick a MethodK and specify where the server you want to query is. You get back the full .q If you use a †s in one of your endpoints in your API, the corresponding querying function will automatically take an additional ‡ argument. If you give ˆ,, nothing will be added to the query string.lOtherwise, this function will insert a value-less query string parameter under the name associated to your †.Example: ĸ>type MyApi = "books" :> QueryFlag "published" :> Get '[JSON] [Book] myApi :: Proxy MyApi myApi = Proxy getBooks :: Bool -> ClientM [Book] getBooks = client myApi -- then you can just use "getBooks" to query that endpoint. -- 'getBooksBy False' for all books -- 'getBooksBy True' to only get _already published_ booksr If you use a ‰­ in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument, a list of values of the type specified by your ‰.EIf you give an empty list, nothing will be added to the query string.ŸOtherwise, this function will take care of inserting a textual representation of your values in the query string, under the same query string parameter name.OYou can control how values for your type are turned into text by specifying a Š instance for your type.Example: ĸqtype MyApi = "books" :> QueryParams "authors" Text :> Get '[JSON] [Book] myApi :: Proxy MyApi myApi = Proxy getBooksBy :: [Text] -> ClientM [Book] getBooksBy = client myApi -- then you can just use "getBooksBy" to query that endpoint. -- 'getBooksBy []' for all books -- 'getBooksBy ["Isaac Asimov", "Robert A. Heinlein"]' -- to get all books by Asimov and Heinleins If you use a ‹š in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of the type specified by your ‹, enclosed in Maybe.?If you give Nothing, nothing will be added to the query string.If you give a non-Œn value, this function will take care of inserting a textual representation of this value in the query string.OYou can control how values for your type are turned into text by specifying a Š instance for your type.Example: ĸ[type MyApi = "books" :> QueryParam "author" Text :> Get '[JSON] [Book] myApi :: Proxy MyApi myApi = Proxy getBooksBy :: Maybe Text -> ClientM [Book] getBooksBy = client myApi -- then you can just use "getBooksBy" to query that endpoint. -- 'getBooksBy Nothing' for all books -- 'getBooksBy (Just "Isaac Asimov")' to get all books by Isaac AsimovtIgnore  in client functions.uIgnore Ž in client functions.vUsing a = combinator in your API doesn't affect the client functions.w If you use a š in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of the type specified by your , wrapped in Maybe.WThat function will take care of encoding this argument as Text in the request headers.(All you need is for your type to have a Š instance.Example: ĸĀnewtype Referer = Referer { referrer :: Text } deriving (Eq, Show, Generic, ToHttpApiData) -- GET /view-my-referer type MyApi = "view-my-referer" :> Header "Referer" Referer :> Get '[JSON] Referer myApi :: Proxy MyApi myApi = Proxy viewReferer :: Maybe Referer -> ClientM Book viewReferer = client myApi -- then you can just use "viewRefer" to query that endpoint -- specifying Nothing or e.g Just "http://haskell.org/" as arguments| If you use a ‘Ĩ in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of a list of the type specified by your ‘|. That function will take care of inserting a textual representation of this value at the right place in the request path.GYou can control how these values are turned into text by specifying a Š instance of your type.Example: ]type MyAPI = "src" :> CaptureAll Text -> Get '[JSON] SourceFile myApi :: Proxy myApi = Proxy …getSourceFile :: [Text] -> ClientM SourceFile getSourceFile = client myApi -- then you can use "getSourceFile" to query that endpoint} If you use a ’š in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of the type specified by your ’|. That function will take care of inserting a textual representation of this value at the right place in the request path.OYou can control how values for this type are turned into text by specifying a Š instance for your type.Example: Õtype MyApi = "books" :> Capture "isbn" Text :> Get '[JSON] Book myApi :: Proxy MyApi myApi = Proxy getBook :: Text -> ClientM Book getBook = client myApi -- then you can just use "getBook" to query that endpoint~The client for “ is simply b. Ėtype MyAPI = "books" :> Get '[JSON] [Book] -- GET /books :<|> "nothing" :> EmptyAPI myApi :: Proxy MyApi myApi = Proxy getAllBooks :: ClientM [Book] (getAllBooks :<|> EmptyClient) = client myApiA client querying function for a ” b5 will actually hand you one function for querying a and another one for querying b", stitching them together with ”#, which really is just like a pair. ĸtype MyApi = "books" :> Get '[JSON] [Book] -- GET /books :<|> "books" :> ReqBody '[JSON] Book :> Post Book -- POST /books myApi :: Proxy MyApi myApi = Proxy getAllBooks :: ClientM [Book] postNewBook :: Book -> ClientM Book (getAllBooks :<|> postNewBook) = client myApibcdefghijklmnopqrstuvwxyz{|}~bcdefggdefbc~}|{zyxwvutsrqponmlkjihbcdefghijklmnopqrstuvwxyz{|}~None!:;<=FHIJKLMNOPQRbcdef"def:;;<=bcHIJKLMNOPQRF None> -./0:;<=EFHIJKLMNOPQR]^_`abcdefg3gdef aE]^_`:;;<=bc-./0•      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNNOOPQRSTUVWXYZ[\]^_`abccdefgghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ‹Ž‘’‘“‹Ž”•–—‹Ž˜™š›‹œ‹œžŸ Ą‹ĒĢ‹ĪĨ‹ĪĶ‹§Ļ‹ĐŠŦ/servant-client-core-0.12-HcpTqRoS8IX6WJaOe47uKX$Servant.Client.Core.Internal.Request&Servant.Client.Core.Internal.RunClient$Servant.Client.Core.Internal.Generic&Servant.Client.Core.Internal.BasicAuth$Servant.Client.Core.Internal.BaseUrl!Servant.Client.Core.Internal.Auth&Servant.Client.Core.Internal.HasClientServant.Client.Core.ReexportServant.Client.CoreResponseresponseStatusCode responseBodyresponseHeadersresponseHttpVersion RequestBodyRequestBodyLBSRequestRequestF requestPathrequestQueryString requestBody requestAcceptrequestHeadersrequestHttpVersion requestMethod ServantErrorFailureResponse DecodeFailureUnsupportedContentTypeInvalidContentTypeHeaderConnectionErrordefaultRequest appendToPathappendToQueryString addHeadersetRequestBodyLBSsetRequestBody$fExceptionServantError$fEqRequestBody$fOrdRequestBody$fReadRequestBody$fShowRequestBody $fEqRequestF$fShowRequestF$fFunctorRequestF$fGenericRequestF $fEqResponse$fShowResponse$fGenericResponse$fEqServantError$fShowServantError$fGenericServantError RunClient runRequestthrowServantErrorcatchServantErrorcheckContentTypeHeader decodedAs GClientList gClientList ClientList GClientLikeL gMkClientL GClientLikeP gMkClientP ClientLikemkClientgenericMkClientLgenericMkClientP$fGClientListclientacc$fGClientList:<|>acc$fGClientLikeL::$fGClientLikeL[][]$fGClientLikePa:$fGClientLikeP:<|>:$fClientLike(->)(->) basicAuthReqInvalidBaseUrlExceptionBaseUrl baseUrlScheme baseUrlHost baseUrlPort baseUrlPathSchemeHttpHttps showBaseUrl parseBaseUrl"$fExceptionInvalidBaseUrlException $fEqBaseUrl $fShowScheme $fEqScheme $fOrdScheme$fGenericScheme $fShowBaseUrl $fOrdBaseUrl$fGenericBaseUrl$fShowInvalidBaseUrlExceptionAuthenticatedRequest unAuthReqAuthClientDatamkAuthenticatedRequest EmptyClient HasClientClientclientWithRouteclientIn$fHasClientm:>$fHasClientm:>0$fHasClientmWithNamedContext$fHasClientm:>1$fHasClientm:>2$fHasClientm:>3$fHasClientm:>4$fHasClientm:>5$fHasClientmRaw$fHasClientm:>6$fHasClientm:>7$fHasClientm:>8$fHasClientm:>9$fHasClientm:>10$fHasClientm:>11$fHasClientm:>12$fHasClientmVerb$fHasClientmVerb0$fHasClientmVerb1$fHasClientmVerb2$fHasClientm:>13$fHasClientm:>14$fHasClientmEmptyAPI$fHasClientm:<|>$fEqEmptyClient$fShowEmptyClient$fBoundedEmptyClient$fEnumEmptyClient+generics-sop-0.3.1.0-EVU7jhdnxwRF3s3P6mpp3PGenerics.SOP.UniverseGeneric#servant-0.12-AQmRz3TDpVo5YDrJHpDgbEServant.API.ReqBodyReqBodyServant.API.QueryParam QueryFlagghc-prim GHC.TypesBoolFalse QueryParams,http-api-data-0.3.7.1-24UzYiqH5SH4P0bIvmMk1PWeb.Internal.HttpApiData ToHttpApiData QueryParambaseGHC.BaseNothingServant.API.Description DescriptionSummary%http-types-0.10-Cmn3ZvBAFrCp8W1yqUS6mNetwork.HTTP.Types.Version HttpVersionServant.API.HeaderHeaderServant.API.Capture CaptureAllCaptureServant.API.EmptyEmptyAPIServant.API.Alternative:<|>