-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Easy-to-use, type-safe, expandable, high-level HTTP library
--   
--   Easy-to-use, type-safe, expandable, high-level HTTP library.
@package req
@version 0.2.0


-- | The documentation below is structured in such a way that most
--   important information goes first: you learn how to do HTTP requests,
--   then how to embed them in any monad you have, then it goes on giving
--   you details about less-common things you may want to know about. The
--   documentation is written with sufficient coverage of details and
--   examples, it's designed to be a complete tutorial on its own.
--   
--   <i>(A modest intro goes here, click on <a>req</a> to start making
--   requests.)</i>
--   
--   <h3>About the library</h3>
--   
--   This is an easy-to-use, type-safe, expandable, high-level HTTP library
--   that just works without any fooling around.
--   
--   What does the “easy-to-use” phrase mean? It means that the library is
--   designed to be beginner-friendly, so it's simple to add it to your
--   monad stack, intuitive to work with, well-documented, and does not get
--   in your way. Doing HTTP requests is a common task and Haskell library
--   for this should be very approachable and clear to beginners, thus
--   certain compromises were made. For example, one cannot currently
--   modify <a>ManagerSettings</a> of default manager because the library
--   always uses the same implicit global manager for simplicity and
--   maximal connection sharing. There is a way to use your own manager
--   with different settings, but it requires a bit more typing.
--   
--   “Type-safe” means that the library is protective and eliminates
--   certain class of errors. For example, we have correct-by-construction
--   <a>Url</a>s, it's guaranteed that user does not send request body when
--   using methods like <a>GET</a> or <a>OPTIONS</a>, amount of implicit
--   assumptions is minimized by making user specify his/her intentions in
--   explicit form (for example, it's not possible to avoid specifying body
--   or method of a request). Authentication methods that assume TLS force
--   user to use TLS on type level. The library carefully hides underlying
--   types from lower-level <tt>http-client</tt> package because it's not
--   safe enough (for example <a>Request</a> is an instance of
--   <a>IsString</a> and if it's malformed, it will blow up at run-time).
--   
--   “Expandable” refers to the ability of the library to be expanded
--   without ugly hacking. For example, it's possible to define your own
--   HTTP methods, new ways to construct body of request, new authorization
--   options, new ways to actually perform request and how to
--   represent/parse response. As user extends the library to satisfy
--   his/her special needs, the new solutions work just like built-ins.
--   That said, all common cases are covered by the library out-of-the-box.
--   
--   “High-level” means that there are less details to worry about. The
--   library is a result of my experiences as a Haskell consultant, working
--   for several clients who have very different projects and so the
--   library adapts easily to any particular style of writing Haskell
--   applications. For example, some people prefer throwing exceptions,
--   while others are concerned with purity: just define
--   <a>handleHttpException</a> accordingly when making your monad instance
--   of <a>MonadHttp</a> and it will play seamlessly. Finally, the library
--   cuts boilerplate considerably and helps write concise, easy to read
--   and maintain code.
--   
--   <h3>Using with other libraries</h3>
--   
--   <ul>
--   <li>You won't need low-level interface of <tt>http-client</tt> most of
--   the time, but when you do, it's better import it qualified because it
--   has naming conflicts with <tt>req</tt>.</li>
--   <li>For streaming of large request bodies see companion package
--   <tt>req-conduit</tt>:
--   <a>https://hackage.haskell.org/package/req-conduit</a>.</li>
--   </ul>
--   
--   <h3>Lightweight, no risk solution</h3>
--   
--   The library uses the following mature packages under the hood to
--   guarantee you best experience without bugs or other funny business:
--   
--   <ul>
--   <li><a>https://hackage.haskell.org/package/http-client</a> — low level
--   HTTP client used everywhere in Haskell.</li>
--   <li><a>https://hackage.haskell.org/package/http-client-tls</a> — TLS
--   (HTTPS) support for <tt>http-client</tt>.</li>
--   </ul>
--   
--   It's important to note that since we leverage well-known libraries
--   that the whole Haskell ecosystem uses, there is no risk in using
--   <tt>req</tt>, as the machinery for performing requests is the same as
--   with <tt>http-conduit</tt> and <tt>wreq</tt>, it's just the API is
--   different.
module Network.HTTP.Req

-- | Make an HTTP request. The function takes 5 arguments, 4 of which
--   specify required parameters and the final <a>Option</a> argument is a
--   collection of optional parameters.
--   
--   Let's go through all the arguments first: <tt>req method url body
--   response options</tt>.
--   
--   <tt>method</tt> is an HTTP method such as <a>GET</a> or <a>POST</a>.
--   The documentation has a dedicated section about HTTP methods below.
--   
--   <tt>url</tt> is a <a>Url</a> that describes location of resource you
--   want to interact with.
--   
--   <tt>body</tt> is a body option such as <a>NoReqBody</a> or
--   <a>ReqBodyJson</a>. The tutorial has a section about HTTP bodies, but
--   usage is very straightforward and should be clear from the examples
--   below.
--   
--   <tt>response</tt> is a type hint how to make and interpret response of
--   HTTP request, out-of-the-box it can be the following:
--   <a>ignoreResponse</a>, <a>jsonResponse</a>, <a>bsResponse</a> (to get
--   strict <a>ByteString</a>), <a>lbsResponse</a> (to get lazy
--   <a>ByteString</a>), and <a>returnRequest</a> (makes no request, just
--   returns response, used for testing).
--   
--   Finally <tt>options</tt> is a <a>Monoid</a> that holds a composite
--   <a>Option</a> for all other optional things like query parameters,
--   headers, non-standard port number, etc. There are quite a few things
--   you can put there, see corresponding section in the documentation. If
--   you don't need anything at all, pass <a>mempty</a>.
--   
--   <b>Note</b> that if you use <a>req</a> to do all your requests,
--   connection sharing and reuse is done for you automatically.
--   
--   See the examples below to get on the speed very quickly.
--   
--   <h4><b>Examples</b></h4>
--   
--   First, this is a piece of boilerplate that should be in place before
--   you try the examples:
--   
--   <pre>
--   {-# LANGUAGE OverloadedStrings #-}
--   
--   module Main (main) where
--   
--   import Control.Exception (throwIO)
--   import Control.Monad
--   import Data.Aeson
--   import Data.Maybe (fromJust)
--   import Data.Monoid ((&lt;&gt;))
--   import Data.Text (Text)
--   import GHC.Generics
--   import Network.HTTP.Req
--   import qualified Data.ByteString.Char8 as B
--   
--   instance MonadHttp IO where
--     handleHttpException = throwIO
--   </pre>
--   
--   We will be making requests against the <a>https://httpbin.org</a>
--   service.
--   
--   Make a GET request, grab 5 random bytes:
--   
--   <pre>
--   main :: IO ()
--   main = do
--     let n :: Int
--         n = 5
--     bs &lt;- req GET (https "httpbin.org" /: "bytes" /~ n) NoReqBody bsResponse mempty
--     B.putStrLn (responseBody bs)
--   </pre>
--   
--   The same, but now we use a query parameter named <tt>"seed"</tt> to
--   control seed of the generator:
--   
--   <pre>
--   main :: IO ()
--   main = do
--     let n, seed :: Int
--         n    = 5
--         seed = 100
--     bs &lt;- req GET (https "httpbin.org" /: "bytes" /~ n) NoReqBody bsResponse $
--       "seed" =: seed
--     B.putStrLn (responseBody bs)
--   </pre>
--   
--   POST JSON data and get some info about the POST request:
--   
--   <pre>
--   data MyData = MyData
--     { size  :: Int
--     , color :: Text
--     } deriving (Show, Generic)
--   
--   instance ToJSON MyData
--   instance FromJSON MyData
--   
--   main :: IO ()
--   main = do
--     let myData = MyData
--           { size  = 6
--           , color = "Green" }
--     v &lt;- req POST (https "httpbin.org" /: "post") (ReqBodyJson myData) jsonResponse mempty
--     print (responseBody v :: Value)
--   </pre>
--   
--   Sending URL-encoded body:
--   
--   <pre>
--   main :: IO ()
--   main = do
--     let params =
--           "foo" =: ("bar" :: Text) &lt;&gt;
--           queryFlag "baz"
--     response &lt;- req POST (https "httpbin.org" /: "post") (ReqBodyUrlEnc params) jsonResponse mempty
--     print (responseBody response :: Value)
--   </pre>
--   
--   Using various optional parameters and URL that is not known in
--   advance:
--   
--   <pre>
--   main :: IO ()
--   main = do
--     -- This is an example of what to do when URL is given dynamically. Of
--     -- course in a real application you may not want to use 'fromJust'.
--     let (url, options) = fromJust (parseUrlHttps "https://httpbin.org/get?foo=bar")
--     response &lt;- req GET url NoReqBody jsonResponse $
--       "from" =: (15 :: Int)           &lt;&gt;
--       "to"   =: (67 :: Int)           &lt;&gt;
--       basicAuth "username" "password" &lt;&gt;
--       options                         &lt;&gt; -- contains the ?foo=bar part
--       port 443 -- here you can put any port of course
--     print (responseBody response :: Value)
--   </pre>
req :: forall m method body response scheme. (MonadHttp m, HttpMethod method, HttpBody body, HttpResponse response, HttpBodyAllowed (AllowsBody method) (ProvidesBody body)) => method -> Url scheme -> body -> Proxy response -> Option scheme -> m response

-- | Perform an action using global implicit <a>Manager</a> that the rest
--   of the library uses. This allows to reuse connections that the
--   <a>Manager</a> controls.
withReqManager :: MonadIO m => (Manager -> m a) -> m a

-- | A type class for monads that support performing HTTP requests.
--   Typically, you only need to define the <a>handleHttpException</a>
--   method unless you want to tweak <a>HttpConfig</a>.
class MonadIO m => MonadHttp m where getHttpConfig = return def

-- | This method describes how to deal with <a>HttpException</a> that was
--   caught by the library. One option is to re-throw it if you are OK with
--   exceptions, but if you prefer working with something like
--   <a>MonadError</a>, this is the right place to pass it to
--   <a>throwError</a>.
handleHttpException :: MonadHttp m => HttpException -> m a

-- | Return <a>HttpConfig</a> to be used when performing HTTP requests.
--   Default implementation returns its <a>def</a> value, which is
--   described in the documentation for the type. Common usage pattern with
--   manually defined <a>getHttpConfig</a> is to return some hard-coded
--   value, or value extracted from <a>MonadReader</a> if a more flexible
--   approach to configuration is desirable.
getHttpConfig :: MonadHttp m => m HttpConfig

-- | <a>HttpConfig</a> contains general and default settings to be used
--   when making HTTP requests.
data HttpConfig
HttpConfig :: Maybe Proxy -> Int -> Maybe Manager -> (Request -> Response BodyReader -> IO ()) -> HttpConfig

-- | Proxy to use. By default values of <tt>HTTP_PROXY</tt> and
--   <tt>HTTPS_PROXY</tt> environment variables are respected, this setting
--   overwrites them. Default value: <a>Nothing</a>.
[httpConfigProxy] :: HttpConfig -> Maybe Proxy

-- | How many redirects to follow when getting a resource. Default value:
--   10.
[httpConfigRedirectCount] :: HttpConfig -> Int

-- | Alternative <a>Manager</a> to use. <a>Nothing</a> (default value)
--   means that default implicit manager will be used (that's what you want
--   in 99% of cases).
[httpConfigAltManager] :: HttpConfig -> Maybe Manager

-- | Function to check the response immediately after receiving the status
--   and headers. This is used for throwing exceptions on non-success
--   status codes by default (set to <tt>\_ _ -&gt; return ()</tt> if this
--   behavior is not desirable). Throwing is better then just returning a
--   request with non-2xx status code because in that case something is
--   wrong and we need a way to short-cut execution. The thrown exception
--   is caught by the library though and is available in
--   <a>handleHttpException</a>.
[httpConfigCheckResponse] :: HttpConfig -> Request -> Response BodyReader -> IO ()

-- | <a>GET</a> method.
data GET
GET :: GET

-- | <a>POST</a> method.
data POST
POST :: POST

-- | <a>HEAD</a> method.
data HEAD
HEAD :: HEAD

-- | <a>PUT</a> method.
data PUT
PUT :: PUT

-- | <a>DELETE</a> method. This data type does not allow having request
--   body with <a>DELETE</a> requests, as it should be, however some APIs
--   may expect <a>DELETE</a> requests to have bodies, in that case define
--   your own variation of <a>DELETE</a> method and allow it to have a
--   body.
data DELETE
DELETE :: DELETE

-- | <a>TRACE</a> method.
data TRACE
TRACE :: TRACE

-- | <a>CONNECT</a> method.
data CONNECT
CONNECT :: CONNECT

-- | <a>OPTIONS</a> method.
data OPTIONS
OPTIONS :: OPTIONS

-- | <a>PATCH</a> method.
data PATCH
PATCH :: PATCH

-- | A type class for types that can be used as an HTTP method. To define a
--   non-standard method, follow this example that defines COPY:
--   
--   <pre>
--   data COPY = COPY
--   
--   instance HttpMethod COPY where
--     type AllowsBody COPY = 'CanHaveBody
--     httpMethodName Proxy = "COPY"
--   </pre>
class HttpMethod a where type AllowsBody a :: CanHaveBody where {
    type family AllowsBody a :: CanHaveBody;
}

-- | Return name of the method as a <a>ByteString</a>.
httpMethodName :: HttpMethod a => Proxy a -> ByteString

-- | Request's <a>Url</a>. Start constructing your <a>Url</a> with
--   <a>http</a> or <a>https</a> specifying the scheme and host at the same
--   time. Then use the <tt>(<a>/~</a>)</tt> and <tt>(<a>/:</a>)</tt>
--   operators to grow path one piece at a time. Every single piece of path
--   will be url(percent)-encoded, so using <tt>(<a>/~</a>)</tt> and
--   <tt>(<a>/:</a>)</tt> is the only way to have forward slashes between
--   path segments. This approach makes working with dynamic path segments
--   easy and safe. See examples below how to represent various <a>Url</a>s
--   (make sure the <tt>OverloadedStrings</tt> language extension is
--   enabled).
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   http "httpbin.org"
--   -- http://httpbin.org
--   </pre>
--   
--   <pre>
--   https "httpbin.org"
--   -- https://httpbin.org
--   </pre>
--   
--   <pre>
--   https "httpbin.org" /: "encoding" /: "utf8"
--   -- https://httpbin.org/encoding/utf8
--   </pre>
--   
--   <pre>
--   https "httpbin.org" /: "foo" /: "bar/baz"
--   -- https://httpbin.org/foo/bar%2Fbaz
--   </pre>
--   
--   <pre>
--   https "httpbin.org" /: "bytes" /~ (10 :: Int)
--   -- https://httpbin.org/bytes/10
--   </pre>
--   
--   <pre>
--   https "юникод.рф"
--   -- https://%D1%8E%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4.%D1%80%D1%84
--   </pre>
data Url (scheme :: Scheme)

-- | Given host name, produce a <a>Url</a> which have “http” as its scheme
--   and empty path. This also sets port to <tt>80</tt>.
http :: Text -> Url Http

-- | Given host name, produce a <a>Url</a> which have “https” as its scheme
--   and empty path. This also sets port to <tt>443</tt>.
https :: Text -> Url Https

-- | Grow given <a>Url</a> appending a single path segment to it. Note that
--   the path segment can be of any type that is an instance of
--   <a>ToHttpApiData</a>.
(/~) :: ToHttpApiData a => Url scheme -> a -> Url scheme
infixl 5 /~

-- | Type-constrained version of <tt>(<a>/~</a>)</tt> to remove ambiguity
--   in cases when next URL piece is a <a>Text</a> literal.
(/:) :: Url scheme -> Text -> Url scheme
infixl 5 /:

-- | The <a>parseUrlHttp</a> function provides an alternative method to get
--   <a>Url</a> (possibly with some <a>Option</a>s) from a
--   <a>ByteString</a>. This is useful when you are given a URL to query
--   dynamically and don't know it beforehand. The function parses
--   <a>ByteString</a> because it's the correct type to represent a URL, as
--   <a>Url</a> cannot contain characters outside of ASCII range, thus we
--   can consider every character a <a>Word8</a> value.
--   
--   This function only parses <a>Url</a> (scheme, host, path) and optional
--   query parameters that are returned as <a>Option</a>. It does not parse
--   method name or authentication info from given <a>ByteString</a>.
parseUrlHttp :: ByteString -> Maybe (Url Http, Option scheme)

-- | Just like <a>parseUrlHttp</a>, but expects “https” scheme.
parseUrlHttps :: ByteString -> Maybe (Url Https, Option scheme)

-- | This data type represents empty body of an HTTP request. This is the
--   data type to use with <a>HttpMethod</a>s that cannot have a body, as
--   it's the only type for which <a>ProvidesBody</a> returns
--   <a>NoBody</a>.
--   
--   Using of this body option does not set the <tt>Content-Type</tt>
--   header.
data NoReqBody
NoReqBody :: NoReqBody

-- | This body option allows to use a JSON object as request body —
--   probably the most popular format right now. Just wrap a data type that
--   is an instance of <a>ToJSON</a> type class and you are done: it will
--   be converted to JSON and inserted as request body.
--   
--   This body option sets the <tt>Content-Type</tt> header to
--   <tt>"application/json; charset=utf-8"</tt> value.
newtype ReqBodyJson a
ReqBodyJson :: a -> ReqBodyJson a

-- | This body option streams request body from a file. It is expected that
--   the file size does not change during the streaming.
--   
--   Using of this body option does not set the <tt>Content-Type</tt>
--   header.
newtype ReqBodyFile
ReqBodyFile :: FilePath -> ReqBodyFile

-- | HTTP request body represented by a strict <a>ByteString</a>.
--   
--   Using of this body option does not set the <tt>Content-Type</tt>
--   header.
newtype ReqBodyBs
ReqBodyBs :: ByteString -> ReqBodyBs

-- | HTTP request body represented by a lazy <a>ByteString</a>.
--   
--   Using of this body option does not set the <tt>Content-Type</tt>
--   header.
newtype ReqBodyLbs
ReqBodyLbs :: ByteString -> ReqBodyLbs

-- | Form URL-encoded body. This can hold a collection of parameters which
--   are encoded similarly to query parameters at the end of query string,
--   with the only difference that they are stored in request body. The
--   similarity is reflected in the API as well, as you can use the same
--   combinators you would use to add query parameters:
--   <tt>(<a>=:</a>)</tt> and <a>queryFlag</a>.
--   
--   This body option sets the <tt>Content-Type</tt> header to
--   <tt>"application/x-www-from-urlencoded"</tt> value.
newtype ReqBodyUrlEnc
ReqBodyUrlEnc :: FormUrlEncodedParam -> ReqBodyUrlEnc

-- | An opaque monoidal value that allows to collect URL-encoded parameters
--   to be wrapped in <a>ReqBodyUrlEnc</a>.
data FormUrlEncodedParam

-- | Multipart form data. Please consult the
--   <a>Network.HTTP.Client.MultipartFormData</a> module for how to
--   construct parts, then use <a>reqBodyMultipart</a> to create actual
--   request body from the parts. <a>reqBodyMultipart</a> is the only way
--   to get a value of type <a>ReqBodyMultipart</a>, as its constructor is
--   not exported on purpose.
data ReqBodyMultipart

-- | Create <a>ReqBodyMultipart</a> request body from a collection of
--   <a>Part</a>s.
reqBodyMultipart :: MonadIO m => [Part] -> m ReqBodyMultipart

-- | A type class for things that can be interpreted as HTTP
--   <a>RequestBody</a>.
class HttpBody body where getRequestContentType = const Nothing

-- | How to get actual <a>RequestBody</a>.
getRequestBody :: HttpBody body => body -> RequestBody

-- | This method allows to optionally specify value of
--   <tt>Content-Type</tt> header that should be used with particular body
--   option. By default it returns <a>Nothing</a> and so
--   <tt>Content-Type</tt> is not set.
getRequestContentType :: HttpBody body => body -> Maybe ByteString

-- | The type function recognizes <a>NoReqBody</a> as having <a>NoBody</a>,
--   while any other body option <a>CanHaveBody</a>. This forces user to
--   use <a>NoReqBody</a> with <a>GET</a> method and other methods that
--   should not send a body.

-- | This type function allows any HTTP body if method says it
--   <a>CanHaveBody</a>. When method says it should have <a>NoBody</a>, the
--   only body option to use is <a>NoReqBody</a>.
--   
--   <b>Note</b>: users of GHC 8.0.1 will see slightly more friendly error
--   messages when method does not allow a body and body is provided.

-- | Opaque <a>Option</a> type is a <a>Monoid</a> you can use to pack
--   collection of optional parameters like query parameters and headers.
--   See sections below to learn which <a>Option</a> primitives are
--   available.
data Option (scheme :: Scheme)

-- | This operator builds a query parameter that will be included in URL of
--   your request after question sign <tt>?</tt>. This is the same syntax
--   you use with form URL encoded request bodies.
--   
--   This operator is defined in terms of <a>queryParam</a>:
--   
--   <pre>
--   name =: value = queryParam name (pure value)
--   </pre>
(=:) :: (QueryParam param, ToHttpApiData a) => Text -> a -> param
infix 7 =:

-- | Construct a flag, that is, valueless query parameter. For example, in
--   the following URL <tt>a</tt> is a flag, <tt>b</tt> is a query
--   parameter with a value:
--   
--   <pre>
--   https://httpbin.org/foo/bar?a&amp;b=10
--   </pre>
--   
--   This operator is defined in terms of <a>queryParam</a>:
--   
--   <pre>
--   queryFlag name = queryParam name Nothing
--   </pre>
queryFlag :: QueryParam param => Text -> param

-- | A type class for query-parameter-like things. The reason to have
--   overloaded <a>queryParam</a> is to be able to use it as an
--   <a>Option</a> and as a <a>FormUrlEncodedParam</a> when constructing
--   form URL encoded request bodies. Having the same syntax for these
--   cases seems natural and user-friendly.
class QueryParam param

-- | Create a query parameter with given name and value. If value is
--   <a>Nothing</a>, it won't be included at all (i.e. you create a flag
--   this way). It's recommended to use <tt>(<a>=:</a>)</tt> and
--   <a>queryFlag</a> instead of this method, because they are easier to
--   read.
queryParam :: (QueryParam param, ToHttpApiData a) => Text -> Maybe a -> param

-- | Create an <a>Option</a> that adds a header. Note that if you
--   <a>mappend</a> two headers with the same names the leftmost header
--   will win. This means, in particular, that you cannot create a request
--   with several headers of the same name.
header :: ByteString -> ByteString -> Option scheme

-- | Use the given <a>CookieJar</a>. A <a>CookieJar</a> can be obtained
--   from a <a>Response</a> record.
cookieJar :: CookieJar -> Option scheme

-- | The <a>Option</a> adds basic authentication.
--   
--   See also:
--   <a>https://en.wikipedia.org/wiki/Basic_access_authentication</a>.
basicAuth :: ByteString -> ByteString -> Option Https

-- | The <a>Option</a> adds OAuth1 authentication.
oAuth1 :: ByteString -> ByteString -> ByteString -> ByteString -> Option scheme

-- | The <a>Option</a> adds an OAuth2 bearer token. This is treated by many
--   services as the equivalent of a username and password.
--   
--   The <a>Option</a> is defined as:
--   
--   <pre>
--   oAuth2Bearer token = header "Authorization" ("Bearer " &lt;&gt; token)
--   </pre>
--   
--   See also: <a>https://en.wikipedia.org/wiki/OAuth</a>.
oAuth2Bearer :: ByteString -> Option Https

-- | The <a>Option</a> adds a not-quite-standard OAuth2 bearer token (that
--   seems to be used only by GitHub). This will be treated by whatever
--   services accept it as the equivalent of a username and password.
--   
--   The <a>Option</a> is defined as:
--   
--   <pre>
--   oAuth2Token token = header "Authorization" ("token" &lt;&gt; token)
--   </pre>
--   
--   See also:
--   <a>https://developer.github.com/v3/oauth#3-use-the-access-token-to-access-the-api</a>.
oAuth2Token :: ByteString -> Option Https

-- | Specify the port to connect to explicitly. Normally, <a>Url</a> you
--   use determines default port, <tt>80</tt> for HTTP and <tt>443</tt> for
--   HTTPS, this <a>Option</a> allows to choose arbitrary port overwriting
--   the defaults.
port :: Int -> Option scheme

-- | This <a>Option</a> controls whether gzipped data should be
--   decompressed on the fly. By default everything except for
--   <tt>application/x-tar</tt> is decompressed, i.e. we have:
--   
--   <pre>
--   decompress (/= "application/x-tar")
--   </pre>
--   
--   You can also choose to decompress everything like this:
--   
--   <pre>
--   decompress (const True)
--   </pre>
decompress :: (ByteString -> Bool) -> Option scheme

-- | Specify number of microseconds to wait for response. Default is 30
--   seconds.
responseTimeout :: Int -> Option scheme

-- | HTTP version to send to server, default is HTTP 1.1.
httpVersion :: Int -> Int -> Option scheme

-- | Make a request and ignore body of response.
data IgnoreResponse

-- | Use this as the fourth argument of <a>req</a> to specify that you want
--   it to return the <a>IgnoreResponse</a> interpretation.
ignoreResponse :: Proxy IgnoreResponse

-- | Make a request and interpret body of response as JSON. The
--   <a>handleHttpException</a> method of <a>MonadHttp</a> instance
--   corresponding to monad in which you use <a>req</a> will determine what
--   to do in the case when parsing fails (<a>JsonHttpException</a>
--   constructor will be used).
data JsonResponse a

-- | Use this as the forth argument of <a>req</a> to specify that you want
--   it to return the <a>JsonResponse</a> interpretation.
jsonResponse :: Proxy (JsonResponse a)

-- | Make a request and interpret body of response as a strict
--   <a>ByteString</a>.
data BsResponse

-- | Use this as the forth argument of <a>req</a> to specify that you want
--   to interpret response body as a strict <a>ByteString</a>.
bsResponse :: Proxy BsResponse

-- | Make a request and interpret body of response as a lazy
--   <a>ByteString</a>.
data LbsResponse

-- | Use this as the forth argument of <a>req</a> to specify that you want
--   to interpret response body as a lazy <a>ByteString</a>.
lbsResponse :: Proxy LbsResponse

-- | This interpretation does not result in any call at all, but you can
--   use the <a>responseRequest</a> function to extract <a>Request</a> that
--   <a>req</a> has prepared. This is useful primarily for testing.
--   
--   Note that when you use this interpretation inspecting response will
--   diverge (i.e. it'll blow up with an error, don't do that).
data ReturnRequest

-- | Use this as the forth argument of <a>req</a> to specify that you want
--   it to just return the request it consturcted without making any
--   requests.
returnRequest :: Proxy ReturnRequest

-- | Get response body.
responseBody :: HttpResponse response => response -> HttpResponseBody response

-- | Get response status code.
responseStatusCode :: HttpResponse response => response -> Int

-- | Get response status message.
responseStatusMessage :: HttpResponse response => response -> ByteString

-- | Look a particular header from a response.
responseHeader :: HttpResponse response => response -> ByteString -> Maybe ByteString

-- | Get response <a>CookieJar</a>.
responseCookieJar :: HttpResponse response => response -> CookieJar

-- | Get the original request from <a>ReturnRequest</a> response
--   interpretation.
responseRequest :: ReturnRequest -> Request

-- | A type class for response interpretations. It allows to fully control
--   how request is made and how its body is parsed.
class HttpResponse response where type HttpResponseBody response :: * where {
    type family HttpResponseBody response :: *;
}

-- | The method describes how to get underlying <a>Response</a> record.
toVanillaResponse :: HttpResponse response => response -> Response (HttpResponseBody response)

-- | This method describes how to make an HTTP request given <a>Request</a>
--   (prepared by the rest of the library) and <a>Manager</a>.
getHttpResponse :: HttpResponse response => Request -> Manager -> IO response

-- | Exceptions that this library throws.
data HttpException

-- | A wrapper with an <a>HttpException</a> from <a>Network.HTTP.Client</a>
VanillaHttpException :: HttpException -> HttpException

-- | A wrapper with Aeson-produced <a>String</a> describing why decoding
--   failed
JsonHttpException :: String -> HttpException

-- | A simple <a>Bool</a>-like type we only have for better error messages.
--   We use it as a kind and its data constructors as type-level tags.
--   
--   See also: <a>HttpMethod</a> and <a>HttpBody</a>.
data CanHaveBody

-- | Indeed can have a body
CanHaveBody :: CanHaveBody

-- | Should not have a body
NoBody :: CanHaveBody

-- | A type-level tag that specifies URL scheme used (and thus if TLS is
--   enabled). This is used to force TLS requirement for some
--   authentication <a>Option</a>s.
data Scheme

-- | HTTP, no TLS
Http :: Scheme

-- | HTTPS
Https :: Scheme
instance GHC.Generics.Generic (Network.HTTP.Req.Url scheme)
instance Data.Typeable.Internal.Typeable scheme => Data.Data.Data (Network.HTTP.Req.Url scheme)
instance GHC.Show.Show (Network.HTTP.Req.Url scheme)
instance GHC.Classes.Ord (Network.HTTP.Req.Url scheme)
instance GHC.Classes.Eq (Network.HTTP.Req.Url scheme)
instance GHC.Generics.Generic Network.HTTP.Req.Scheme
instance Data.Data.Data Network.HTTP.Req.Scheme
instance GHC.Show.Show Network.HTTP.Req.Scheme
instance GHC.Classes.Ord Network.HTTP.Req.Scheme
instance GHC.Classes.Eq Network.HTTP.Req.Scheme
instance GHC.Generics.Generic Network.HTTP.Req.HttpException
instance GHC.Show.Show Network.HTTP.Req.HttpException
instance GHC.Base.Monoid Network.HTTP.Req.FormUrlEncodedParam
instance Data.Semigroup.Semigroup Network.HTTP.Req.FormUrlEncodedParam
instance Data.Default.Class.Default Network.HTTP.Req.HttpConfig
instance Network.HTTP.Req.RequestComponent Network.HTTP.Req.HttpConfig
instance Network.HTTP.Req.HttpMethod Network.HTTP.Req.GET
instance Network.HTTP.Req.HttpMethod Network.HTTP.Req.POST
instance Network.HTTP.Req.HttpMethod Network.HTTP.Req.HEAD
instance Network.HTTP.Req.HttpMethod Network.HTTP.Req.PUT
instance Network.HTTP.Req.HttpMethod Network.HTTP.Req.DELETE
instance Network.HTTP.Req.HttpMethod Network.HTTP.Req.TRACE
instance Network.HTTP.Req.HttpMethod Network.HTTP.Req.CONNECT
instance Network.HTTP.Req.HttpMethod Network.HTTP.Req.OPTIONS
instance Network.HTTP.Req.HttpMethod Network.HTTP.Req.PATCH
instance Network.HTTP.Req.HttpMethod method => Network.HTTP.Req.RequestComponent (Network.HTTP.Req.Womb "method" method)
instance Network.HTTP.Req.RequestComponent (Network.HTTP.Req.Url scheme)
instance Network.HTTP.Req.HttpBody Network.HTTP.Req.NoReqBody
instance Data.Aeson.Types.ToJSON.ToJSON a => Network.HTTP.Req.HttpBody (Network.HTTP.Req.ReqBodyJson a)
instance Network.HTTP.Req.HttpBody Network.HTTP.Req.ReqBodyFile
instance Network.HTTP.Req.HttpBody Network.HTTP.Req.ReqBodyBs
instance Network.HTTP.Req.HttpBody Network.HTTP.Req.ReqBodyLbs
instance Network.HTTP.Req.HttpBody Network.HTTP.Req.ReqBodyUrlEnc
instance Network.HTTP.Req.QueryParam Network.HTTP.Req.FormUrlEncodedParam
instance Network.HTTP.Req.HttpBody Network.HTTP.Req.ReqBodyMultipart
instance Network.HTTP.Req.HttpBody body => Network.HTTP.Req.RequestComponent (Network.HTTP.Req.Womb "body" body)
instance Data.Semigroup.Semigroup (Network.HTTP.Req.Option scheme)
instance GHC.Base.Monoid (Network.HTTP.Req.Option scheme)
instance Network.HTTP.Req.RequestComponent (Network.HTTP.Req.Option scheme)
instance Network.HTTP.Req.QueryParam (Network.HTTP.Req.Option scheme)
instance Network.HTTP.Req.HttpResponse Network.HTTP.Req.IgnoreResponse
instance Data.Aeson.Types.FromJSON.FromJSON a => Network.HTTP.Req.HttpResponse (Network.HTTP.Req.JsonResponse a)
instance Network.HTTP.Req.HttpResponse Network.HTTP.Req.BsResponse
instance Network.HTTP.Req.HttpResponse Network.HTTP.Req.LbsResponse
instance Network.HTTP.Req.HttpResponse Network.HTTP.Req.ReturnRequest
instance GHC.Exception.Exception Network.HTTP.Req.HttpException
