    {-# LANGUAGE CPP #-}
    {-# LANGUAGE ApplicativeDo #-}
    {-# OPTIONS_GHC -Wno-missing-methods #-}
    module Servant.Client.Core.HasClient (
        clientIn,
        HasClient (..),
        EmptyClient (..),
        AsClientT,
        (//),
        (/:),
        foldMapUnion,
        matchUnion,
        fromSomeClientResponse
        ) where

    import           Prelude ()
    import           Prelude.Compat

    import           Control.Arrow
                     (left, (+++))
    import qualified Data.Text as Text
    import           Control.Monad
                     (unless)
    import qualified Data.ByteString.Lazy as BSL
    import           Data.Either
                     (partitionEithers)
    import           Data.Constraint (Dict(..))
    import           Data.Foldable
                     (toList)
    import           Data.Kind
                     (Type)
    import qualified Data.List as List
    import           Data.Sequence
                     (fromList)
    import qualified Data.Text                       as T
    import           Data.Text.Encoding (encodeUtf8)
    import           Network.HTTP.Media
                     (MediaType, matches, parseAccept)
    import qualified Network.HTTP.Media as Media
    import qualified Data.Sequence as Seq
    import           Data.SOP.BasicFunctors
                     (I (I), (:.:) (Comp))
    import           Data.SOP.Constraint
                     (All)
    import           Data.SOP.NP
                     (NP (..), cpure_NP)
    import           Data.SOP.NS
                     (NS (..))
    import           Data.String
                     (fromString)
    import           Data.Text
                     (Text, pack)
    import           GHC.TypeLits
                     (KnownNat, KnownSymbol, TypeError, symbolVal)
    import           Network.HTTP.Types
                     (Status)
    import qualified Network.HTTP.Types                       as H
    import           Servant.API
                     ((:<|>) ((:<|>)), (:>),
                     BuildHeadersTo (..),
                     EmptyAPI,
                     FromSourceIO (..),
                     IsSecure,
                     MimeUnrender (mimeUnrender),
                     NoContentVerb,
                     ReflectMethod (..),
                     StreamBody',
                     Verb,
                     getResponse, AuthProtect, BasicAuth, BasicAuthData, Capture', CaptureAll, DeepQuery, Description, Fragment, FramingRender (..), FramingUnrender (..), Header', Headers (..), HttpVersion, MimeRender (mimeRender), NoContent (NoContent), QueryFlag, QueryParam', QueryParams, QueryString, Raw, RawM, RemoteHost, ReqBody', SBoolI, Stream, Summary, ToHttpApiData, ToSourceIO (..), Vault, WithNamedContext, WithResource, WithStatus (..), contentType, getHeadersHList, toEncodedUrlPiece, NamedRoutes, Host)
    import           Servant.API.Generic
                     (GenericMode(..), ToServant, ToServantApi
                     , GenericServant, toServant, fromServant)
    import           Servant.API.ContentTypes
                     (contentTypes, AllMime (allMime), AllMimeUnrender (allMimeUnrender), EventStream)
    import           Servant.API.QueryString (ToDeepQuery(..), generateDeepParam)
    import           Servant.API.Status
                     (statusFromNat)
    import           Servant.API.TypeLevel (FragmentUnique, AtMostOneFragment)
    import           Servant.API.Modifiers
                     (FoldRequired, RequiredArgument, foldRequiredArgument)
    import           Servant.API.TypeErrors
    import           Servant.API.UVerb
                     (HasStatus, HasStatuses (Statuses, statuses), UVerb, Union, Unique, inject, statusOf, foldMapUnion, matchUnion)
    import           Servant.API.ServerSentEvents
                     (EventKind (JsonEvent, RawEvent), ServerSentEvents')
    import           Servant.API.Stream
                     (NoFraming)

    import           Servant.Client.Core.Auth
    import           Servant.Client.Core.BasicAuth
    import           Servant.Client.Core.ClientError
    import           Servant.Client.Core.Request
    import           Servant.Client.Core.Response
    import           Servant.Client.Core.MultiVerb.ResponseUnrender
    import qualified Servant.Client.Core.Response as Response
    import           Servant.Client.Core.RunClient
    import           Servant.Client.Core.ServerSentEvents
    import           Servant.API.MultiVerb
    import qualified Network.HTTP.Media as M
    import           Data.Typeable

    -- * Accessing APIs as a Client

    -- | 'clientIn' allows you to produce operations to query an API from a client
    -- within a 'RunClient' monad.
    --
    -- > type 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` clientM
    clientIn :: HasClient m api => Proxy api -> Proxy m -> Client m api
    clientIn :: forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy api -> Proxy m -> Client m api
    clientIn Proxy api
    p Proxy m
    pm = Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm Proxy api
    p Request
    defaultRequest

    -- | 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.
    class RunClient m => HasClient m api where
      type Client (m :: Type -> Type) (api :: Type) :: Type
      clientWithRoute :: Proxy m -> Proxy api -> Request -> Client m api
      hoistClientMonad
        :: Proxy m
        -> Proxy api
        -> (forall x. mon x -> mon' x)
        -> Client mon api
        -> Client mon' api

    -- | A client querying function for @a ':<|>' b@ 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 myApi
    instance (HasClient m a, HasClient m b) => HasClient m (a :<|> b) where
      type Client m (a :<|> b) = Client m a :<|> Client m b
      clientWithRoute :: Proxy m -> Proxy (a :<|> b) -> Request -> Client m (a :<|> b)
    clientWithRoute Proxy m
    pm Proxy (a :<|> b)
    Proxy Request
    req =
        Proxy m -> Proxy a -> Request -> Client m a
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy a
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy a) Request
    req Client m a -> Client m b -> Client m a :<|> Client m b
    forall a b. a -> b -> a :<|> b
    :<|>
        Proxy m -> Proxy b -> Request -> Client m b
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy b
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy b) Request
    req

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (a :<|> b)
    -> (forall x. mon x -> mon' x)
    -> Client mon (a :<|> b)
    -> Client mon' (a :<|> b)
    hoistClientMonad Proxy m
    pm Proxy (a :<|> b)
    _ forall x. mon x -> mon' x
    f (Client mon a
    ca :<|> Client mon b
    cb) =
        Proxy m
    -> Proxy a
    -> (forall x. mon x -> mon' x)
    -> Client mon a
    -> Client mon' a
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy a
    -> (forall x. mon x -> mon' x)
    -> Client mon a
    -> Client mon' a
    hoistClientMonad Proxy m
    pm (Proxy a
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy a) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon a
    ca Client mon' a -> Client mon' b -> Client mon' a :<|> Client mon' b
    forall a b. a -> b -> a :<|> b
    :<|>
        Proxy m
    -> Proxy b
    -> (forall x. mon x -> mon' x)
    -> Client mon b
    -> Client mon' b
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy b
    -> (forall x. mon x -> mon' x)
    -> Client mon b
    -> Client mon' b
    hoistClientMonad Proxy m
    pm (Proxy b
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy b) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon b
    cb

    -- | Singleton type representing a client for an empty API.
    data EmptyClient = EmptyClient deriving (EmptyClient -> EmptyClient -> Bool
    (EmptyClient -> EmptyClient -> Bool)
    -> (EmptyClient -> EmptyClient -> Bool) -> Eq EmptyClient
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EmptyClient -> EmptyClient -> Bool
    == :: EmptyClient -> EmptyClient -> Bool
    $c/= :: EmptyClient -> EmptyClient -> Bool
    /= :: EmptyClient -> EmptyClient -> Bool
    Eq, Int -> EmptyClient -> ShowS
    [EmptyClient] -> ShowS
    EmptyClient -> String
    (Int -> EmptyClient -> ShowS)
    -> (EmptyClient -> String)
    -> ([EmptyClient] -> ShowS)
    -> Show EmptyClient
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EmptyClient -> ShowS
    showsPrec :: Int -> EmptyClient -> ShowS
    $cshow :: EmptyClient -> String
    show :: EmptyClient -> String
    $cshowList :: [EmptyClient] -> ShowS
    showList :: [EmptyClient] -> ShowS
    Show, EmptyClient
    EmptyClient -> EmptyClient -> Bounded EmptyClient
    forall a. a -> a -> Bounded a
    $cminBound :: EmptyClient
    minBound :: EmptyClient
    $cmaxBound :: EmptyClient
    maxBound :: EmptyClient
    Bounded, Int -> EmptyClient
    EmptyClient -> Int
    EmptyClient -> [EmptyClient]
    EmptyClient -> EmptyClient
    EmptyClient -> EmptyClient -> [EmptyClient]
    EmptyClient -> EmptyClient -> EmptyClient -> [EmptyClient]
    (EmptyClient -> EmptyClient)
    -> (EmptyClient -> EmptyClient)
    -> (Int -> EmptyClient)
    -> (EmptyClient -> Int)
    -> (EmptyClient -> [EmptyClient])
    -> (EmptyClient -> EmptyClient -> [EmptyClient])
    -> (EmptyClient -> EmptyClient -> [EmptyClient])
    -> (EmptyClient -> EmptyClient -> EmptyClient -> [EmptyClient])
    -> Enum EmptyClient
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: EmptyClient -> EmptyClient
    succ :: EmptyClient -> EmptyClient
    $cpred :: EmptyClient -> EmptyClient
    pred :: EmptyClient -> EmptyClient
    $ctoEnum :: Int -> EmptyClient
    toEnum :: Int -> EmptyClient
    $cfromEnum :: EmptyClient -> Int
    fromEnum :: EmptyClient -> Int
    $cenumFrom :: EmptyClient -> [EmptyClient]
    enumFrom :: EmptyClient -> [EmptyClient]
    $cenumFromThen :: EmptyClient -> EmptyClient -> [EmptyClient]
    enumFromThen :: EmptyClient -> EmptyClient -> [EmptyClient]
    $cenumFromTo :: EmptyClient -> EmptyClient -> [EmptyClient]
    enumFromTo :: EmptyClient -> EmptyClient -> [EmptyClient]
    $cenumFromThenTo :: EmptyClient -> EmptyClient -> EmptyClient -> [EmptyClient]
    enumFromThenTo :: EmptyClient -> EmptyClient -> EmptyClient -> [EmptyClient]
    Enum)

    -- | The client for 'EmptyAPI' is simply 'EmptyClient'.
    --
    -- > type MyAPI = "books" :> Get '[JSON] [Book] -- GET /books
    -- >         :<|> "nothing" :> EmptyAPI
    -- >
    -- > myApi :: Proxy MyApi
    -- > myApi = Proxy
    -- >
    -- > getAllBooks :: ClientM [Book]
    -- > (getAllBooks :<|> EmptyClient) = client myApi
    instance RunClient m => HasClient m EmptyAPI where
      type Client m EmptyAPI = EmptyClient
      clientWithRoute :: Proxy m -> Proxy EmptyAPI -> Request -> Client m EmptyAPI
    clientWithRoute Proxy m
    _pm Proxy EmptyAPI
    Proxy Request
    _ = EmptyClient
    Client m EmptyAPI
    EmptyClient
      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy EmptyAPI
    -> (forall x. mon x -> mon' x)
    -> Client mon EmptyAPI
    -> Client mon' EmptyAPI
    hoistClientMonad Proxy m
    _ Proxy EmptyAPI
    _ forall x. mon x -> mon' x
    _ EmptyClient
    Client mon EmptyAPI
    EmptyClient = EmptyClient
    Client mon' EmptyAPI
    EmptyClient

    -- | If you use a 'Capture' in one of your endpoints in your API,
    -- the corresponding querying function will automatically take
    -- an additional argument of the type specified by your 'Capture'.
    -- That function will take care of inserting a textual representation
    -- of this value at the right place in the request path.
    --
    -- You can control how values for this type are turned into
    -- text by specifying a 'ToHttpApiData' 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
    instance (ToHttpApiData a, HasClient m api)
          => HasClient m (Capture' mods capture a :> api) where

      type Client m (Capture' mods capture a :> api) =
        a -> Client m api

      clientWithRoute :: Proxy m
    -> Proxy (Capture' mods capture a :> api)
    -> Request
    -> Client m (Capture' mods capture a :> api)
    clientWithRoute Proxy m
    pm Proxy (Capture' mods capture a :> api)
    Proxy Request
    req a
    val =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)
                        (Builder -> Request -> Request
    appendToPath Builder
    p Request
    req)

        where p :: Builder
    p = a -> Builder
    forall a. ToHttpApiData a => a -> Builder
    toEncodedUrlPiece a
    val

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Capture' mods capture a :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Capture' mods capture a :> api)
    -> Client mon' (Capture' mods capture a :> api)
    hoistClientMonad Proxy m
    pm Proxy (Capture' mods capture a :> api)
    _ forall x. mon x -> mon' x
    f Client mon (Capture' mods capture a :> api)
    cl = \a
    a ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (Capture' mods capture a :> api)
    a -> Client mon api
    cl a
    a)

    -- | If you use a 'CaptureAll' 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
    -- 'CaptureAll'. That function will take care of inserting a textual
    -- representation of this value at the right place in the request
    -- path.
    --
    -- You can control how these values are turned into text by specifying
    -- a 'ToHttpApiData' 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
    instance (ToHttpApiData a, HasClient m sublayout)
          => HasClient m (CaptureAll capture a :> sublayout) where

      type Client m (CaptureAll capture a :> sublayout) =
        [a] -> Client m sublayout

      clientWithRoute :: Proxy m
    -> Proxy (CaptureAll capture a :> sublayout)
    -> Request
    -> Client m (CaptureAll capture a :> sublayout)
    clientWithRoute Proxy m
    pm Proxy (CaptureAll capture a :> sublayout)
    Proxy Request
    req [a]
    vals =
        Proxy m -> Proxy sublayout -> Request -> Client m sublayout
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy sublayout
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy sublayout)
                        ((Request -> Builder -> Request) -> Request -> [Builder] -> Request
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: Type -> Type) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    List.foldl' ((Builder -> Request -> Request) -> Request -> Builder -> Request
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Builder -> Request -> Request
    appendToPath) Request
    req [Builder]
    ps)

        where ps :: [Builder]
    ps = (a -> Builder) -> [a] -> [Builder]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> Builder
    forall a. ToHttpApiData a => a -> Builder
    toEncodedUrlPiece [a]
    vals

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (CaptureAll capture a :> sublayout)
    -> (forall x. mon x -> mon' x)
    -> Client mon (CaptureAll capture a :> sublayout)
    -> Client mon' (CaptureAll capture a :> sublayout)
    hoistClientMonad Proxy m
    pm Proxy (CaptureAll capture a :> sublayout)
    _ forall x. mon x -> mon' x
    f Client mon (CaptureAll capture a :> sublayout)
    cl = \[a]
    as ->
        Proxy m
    -> Proxy sublayout
    -> (forall x. mon x -> mon' x)
    -> Client mon sublayout
    -> Client mon' sublayout
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy sublayout
    -> (forall x. mon x -> mon' x)
    -> Client mon sublayout
    -> Client mon' sublayout
    hoistClientMonad Proxy m
    pm (Proxy sublayout
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy sublayout) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (CaptureAll capture a :> sublayout)
    [a] -> Client mon sublayout
    cl [a]
    as)

    instance {-# OVERLAPPABLE #-}
      -- Note [Non-Empty Content Types]
      ( RunClient m, MimeUnrender ct a, ReflectMethod method, cts' ~ (ct ': cts)
      , KnownNat status
      ) => HasClient m (Verb method status cts' a) where
      type Client m (Verb method status cts' a) = m a
      clientWithRoute :: Proxy m
    -> Proxy (Verb method status cts' a)
    -> Request
    -> Client m (Verb method status cts' a)
    clientWithRoute Proxy m
    _pm Proxy (Verb method status cts' a)
    Proxy Request
    req = do
        Response
    response <- Maybe [Status] -> Request -> m Response
    forall (m :: Type -> Type).
    RunClient m =>
    Maybe [Status] -> Request -> m Response
    runRequestAcceptStatus ([Status] -> Maybe [Status]
    forall a. a -> Maybe a
    Just [Status
    status]) Request
    req
          { requestAccept = fromList $ toList accept
          , requestMethod = method
          }
        Response
    response Response -> Proxy ct -> m a
    forall {k} (ct :: k) a (m :: Type -> Type).
    (MimeUnrender ct a, RunClient m) =>
    Response -> Proxy ct -> m a
    `decodedAs` (Proxy ct
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy ct)
        where
          accept :: NonEmpty MediaType
    accept = Proxy ct -> NonEmpty MediaType
    forall {k} (ctype :: k).
    Accept ctype =>
    Proxy ctype -> NonEmpty MediaType
    contentTypes (Proxy ct
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy ct)
          method :: Method
    method = Proxy method -> Method
    forall {k} (a :: k). ReflectMethod a => Proxy a -> Method
    reflectMethod (Proxy method
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy method)
          status :: Status
    status = Proxy status -> Status
    forall (a :: Nat) (proxy :: Nat -> Type).
    KnownNat a =>
    proxy a -> Status
    statusFromNat (Proxy status
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy status)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Verb method status cts' a)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Verb method status cts' a)
    -> Client mon' (Verb method status cts' a)
    hoistClientMonad Proxy m
    _ Proxy (Verb method status cts' a)
    _ forall x. mon x -> mon' x
    f Client mon (Verb method status cts' a)
    ma = mon a -> mon' a
    forall x. mon x -> mon' x
    f mon a
    Client mon (Verb method status cts' a)
    ma

    instance {-# OVERLAPPING #-}
      ( RunClient m, ReflectMethod method, KnownNat status
      ) => HasClient m (Verb method status cts NoContent) where
      type Client m (Verb method status cts NoContent)
        = m NoContent
      clientWithRoute :: Proxy m
    -> Proxy (Verb method status cts NoContent)
    -> Request
    -> Client m (Verb method status cts NoContent)
    clientWithRoute Proxy m
    _pm Proxy (Verb method status cts NoContent)
    Proxy Request
    req = do
        Response
    _response <- Maybe [Status] -> Request -> m Response
    forall (m :: Type -> Type).
    RunClient m =>
    Maybe [Status] -> Request -> m Response
    runRequestAcceptStatus ([Status] -> Maybe [Status]
    forall a. a -> Maybe a
    Just [Status
    status]) Request
    req { requestMethod = method }
        return NoContent
    NoContent
          where method :: Method
    method = Proxy method -> Method
    forall {k} (a :: k). ReflectMethod a => Proxy a -> Method
    reflectMethod (Proxy method
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy method)
                status :: Status
    status = Proxy status -> Status
    forall (a :: Nat) (proxy :: Nat -> Type).
    KnownNat a =>
    proxy a -> Status
    statusFromNat (Proxy status
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy status)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Verb method status cts NoContent)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Verb method status cts NoContent)
    -> Client mon' (Verb method status cts NoContent)
    hoistClientMonad Proxy m
    _ Proxy (Verb method status cts NoContent)
    _ forall x. mon x -> mon' x
    f Client mon (Verb method status cts NoContent)
    ma = mon NoContent -> mon' NoContent
    forall x. mon x -> mon' x
    f mon NoContent
    Client mon (Verb method status cts NoContent)
    ma

    instance (RunClient m, ReflectMethod method) =>
             HasClient m (NoContentVerb method) where
      type Client m (NoContentVerb method)
        = m NoContent
      clientWithRoute :: Proxy m
    -> Proxy (NoContentVerb method)
    -> Request
    -> Client m (NoContentVerb method)
    clientWithRoute Proxy m
    _pm Proxy (NoContentVerb method)
    Proxy Request
    req = do
        Response
    _response <- Request -> m Response
    forall (m :: Type -> Type). RunClient m => Request -> m Response
    runRequest Request
    req { requestMethod = method }
        return NoContent
    NoContent
          where method :: Method
    method = Proxy method -> Method
    forall {k} (a :: k). ReflectMethod a => Proxy a -> Method
    reflectMethod (Proxy method
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy method)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (NoContentVerb method)
    -> (forall x. mon x -> mon' x)
    -> Client mon (NoContentVerb method)
    -> Client mon' (NoContentVerb method)
    hoistClientMonad Proxy m
    _ Proxy (NoContentVerb method)
    _ forall x. mon x -> mon' x
    f Client mon (NoContentVerb method)
    ma = mon NoContent -> mon' NoContent
    forall x. mon x -> mon' x
    f mon NoContent
    Client mon (NoContentVerb method)
    ma

    instance {-# OVERLAPPING #-}
      -- Note [Non-Empty Content Types]
      ( RunClient m, MimeUnrender ct a, BuildHeadersTo ls, KnownNat status
      , ReflectMethod method, cts' ~ (ct ': cts)
      ) => HasClient m (Verb method status cts' (Headers ls a)) where
      type Client m (Verb method status cts' (Headers ls a))
        = m (Headers ls a)
      clientWithRoute :: Proxy m
    -> Proxy (Verb method status cts' (Headers ls a))
    -> Request
    -> Client m (Verb method status cts' (Headers ls a))
    clientWithRoute Proxy m
    _pm Proxy (Verb method status cts' (Headers ls a))
    Proxy Request
    req = do
        Response
    response <- Maybe [Status] -> Request -> m Response
    forall (m :: Type -> Type).
    RunClient m =>
    Maybe [Status] -> Request -> m Response
    runRequestAcceptStatus ([Status] -> Maybe [Status]
    forall a. a -> Maybe a
    Just [Status
    status]) Request
    req
           { requestMethod = method
           , requestAccept = fromList $ toList accept
           }
        a
    val <- Response
    response Response -> Proxy ct -> m a
    forall {k} (ct :: k) a (m :: Type -> Type).
    (MimeUnrender ct a, RunClient m) =>
    Response -> Proxy ct -> m a
    `decodedAs` (Proxy ct
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy ct)
        return $ Headers { getResponse :: a
    getResponse = a
    val
                         , getHeadersHList :: HList ls
    getHeadersHList = [Header] -> HList ls
    forall (hs :: [Type]). BuildHeadersTo hs => [Header] -> HList hs
    buildHeadersTo ([Header] -> HList ls)
    -> (Seq Header -> [Header]) -> Seq Header -> HList ls
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Seq Header -> [Header]
    forall a. Seq a -> [a]
    forall (t :: Type -> Type) a. Foldable t => t a -> [a]
    toList (Seq Header -> HList ls) -> Seq Header -> HList ls
    forall a b. (a -> b) -> a -> b
    $ Response -> Seq Header
    forall a. ResponseF a -> Seq Header
    responseHeaders Response
    response
                         }
        where
          method :: Method
    method = Proxy method -> Method
    forall {k} (a :: k). ReflectMethod a => Proxy a -> Method
    reflectMethod (Proxy method
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy method)
          accept :: NonEmpty MediaType
    accept = Proxy ct -> NonEmpty MediaType
    forall {k} (ctype :: k).
    Accept ctype =>
    Proxy ctype -> NonEmpty MediaType
    contentTypes (Proxy ct
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy ct)
          status :: Status
    status = Proxy status -> Status
    forall (a :: Nat) (proxy :: Nat -> Type).
    KnownNat a =>
    proxy a -> Status
    statusFromNat (Proxy status
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy status)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Verb method status cts' (Headers ls a))
    -> (forall x. mon x -> mon' x)
    -> Client mon (Verb method status cts' (Headers ls a))
    -> Client mon' (Verb method status cts' (Headers ls a))
    hoistClientMonad Proxy m
    _ Proxy (Verb method status cts' (Headers ls a))
    _ forall x. mon x -> mon' x
    f Client mon (Verb method status cts' (Headers ls a))
    ma = mon (Headers ls a) -> mon' (Headers ls a)
    forall x. mon x -> mon' x
    f mon (Headers ls a)
    Client mon (Verb method status cts' (Headers ls a))
    ma

    instance {-# OVERLAPPING #-}
      ( RunClient m, BuildHeadersTo ls, ReflectMethod method, KnownNat status
      ) => HasClient m (Verb method status cts (Headers ls NoContent)) where
      type Client m (Verb method status cts (Headers ls NoContent))
        = m (Headers ls NoContent)
      clientWithRoute :: Proxy m
    -> Proxy (Verb method status cts (Headers ls NoContent))
    -> Request
    -> Client m (Verb method status cts (Headers ls NoContent))
    clientWithRoute Proxy m
    _pm Proxy (Verb method status cts (Headers ls NoContent))
    Proxy Request
    req = do
        Response
    response <- Maybe [Status] -> Request -> m Response
    forall (m :: Type -> Type).
    RunClient m =>
    Maybe [Status] -> Request -> m Response
    runRequestAcceptStatus ([Status] -> Maybe [Status]
    forall a. a -> Maybe a
    Just [Status
    status]) Request
    req { requestMethod = method }
        return $ Headers { getResponse :: NoContent
    getResponse = NoContent
    NoContent
                         , getHeadersHList :: HList ls
    getHeadersHList = [Header] -> HList ls
    forall (hs :: [Type]). BuildHeadersTo hs => [Header] -> HList hs
    buildHeadersTo ([Header] -> HList ls)
    -> (Seq Header -> [Header]) -> Seq Header -> HList ls
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Seq Header -> [Header]
    forall a. Seq a -> [a]
    forall (t :: Type -> Type) a. Foldable t => t a -> [a]
    toList (Seq Header -> HList ls) -> Seq Header -> HList ls
    forall a b. (a -> b) -> a -> b
    $ Response -> Seq Header
    forall a. ResponseF a -> Seq Header
    responseHeaders Response
    response
                         }
        where
          method :: Method
    method = Proxy method -> Method
    forall {k} (a :: k). ReflectMethod a => Proxy a -> Method
    reflectMethod (Proxy method
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy method)
          status :: Status
    status = Proxy status -> Status
    forall (a :: Nat) (proxy :: Nat -> Type).
    KnownNat a =>
    proxy a -> Status
    statusFromNat (Proxy status
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy status)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Verb method status cts (Headers ls NoContent))
    -> (forall x. mon x -> mon' x)
    -> Client mon (Verb method status cts (Headers ls NoContent))
    -> Client mon' (Verb method status cts (Headers ls NoContent))
    hoistClientMonad Proxy m
    _ Proxy (Verb method status cts (Headers ls NoContent))
    _ forall x. mon x -> mon' x
    f Client mon (Verb method status cts (Headers ls NoContent))
    ma = mon (Headers ls NoContent) -> mon' (Headers ls NoContent)
    forall x. mon x -> mon' x
    f mon (Headers ls NoContent)
    Client mon (Verb method status cts (Headers ls NoContent))
    ma

    data ClientParseError = ClientParseError MediaType String | ClientStatusMismatch | ClientNoMatchingStatus
      deriving (ClientParseError -> ClientParseError -> Bool
    (ClientParseError -> ClientParseError -> Bool)
    -> (ClientParseError -> ClientParseError -> Bool)
    -> Eq ClientParseError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ClientParseError -> ClientParseError -> Bool
    == :: ClientParseError -> ClientParseError -> Bool
    $c/= :: ClientParseError -> ClientParseError -> Bool
    /= :: ClientParseError -> ClientParseError -> Bool
    Eq, Int -> ClientParseError -> ShowS
    [ClientParseError] -> ShowS
    ClientParseError -> String
    (Int -> ClientParseError -> ShowS)
    -> (ClientParseError -> String)
    -> ([ClientParseError] -> ShowS)
    -> Show ClientParseError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ClientParseError -> ShowS
    showsPrec :: Int -> ClientParseError -> ShowS
    $cshow :: ClientParseError -> String
    show :: ClientParseError -> String
    $cshowList :: [ClientParseError] -> ShowS
    showList :: [ClientParseError] -> ShowS
    Show)

    class UnrenderResponse (cts :: [Type]) (a :: Type) where
      unrenderResponse :: Seq.Seq H.Header -> BSL.ByteString -> Proxy cts
                       -> [Either (MediaType, String) a]

    instance {-# OVERLAPPABLE #-} AllMimeUnrender cts a => UnrenderResponse cts a where
      unrenderResponse :: Seq Header
    -> ByteString -> Proxy cts -> [Either (MediaType, String) a]
    unrenderResponse Seq Header
    _ ByteString
    body = ((MediaType, ByteString -> Either String a)
     -> Either (MediaType, String) a)
    -> [(MediaType, ByteString -> Either String a)]
    -> [Either (MediaType, String) a]
    forall a b. (a -> b) -> [a] -> [b]
    map (MediaType, ByteString -> Either String a)
    -> Either (MediaType, String) a
    parse ([(MediaType, ByteString -> Either String a)]
     -> [Either (MediaType, String) a])
    -> (Proxy cts -> [(MediaType, ByteString -> Either String a)])
    -> Proxy cts
    -> [Either (MediaType, String) a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy cts -> [(MediaType, ByteString -> Either String a)]
    forall (list :: [Type]) a.
    AllMimeUnrender list a =>
    Proxy list -> [(MediaType, ByteString -> Either String a)]
    allMimeUnrender
        where parse :: (MediaType, ByteString -> Either String a)
    -> Either (MediaType, String) a
    parse (MediaType
    mediaType, ByteString -> Either String a
    parser) = (String -> (MediaType, String))
    -> Either String a -> Either (MediaType, String) a
    forall b c d. (b -> c) -> Either b d -> Either c d
    forall (a :: Type -> Type -> Type) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    left ((,) MediaType
    mediaType) (ByteString -> Either String a
    parser ByteString
    body)

    instance {-# OVERLAPPING #-} forall cts a h . (UnrenderResponse cts a, BuildHeadersTo h)
      => UnrenderResponse cts (Headers h a) where
      unrenderResponse :: Seq Header
    -> ByteString
    -> Proxy cts
    -> [Either (MediaType, String) (Headers h a)]
    unrenderResponse Seq Header
    hs ByteString
    body = ((Either (MediaType, String) a
     -> Either (MediaType, String) (Headers h a))
    -> [Either (MediaType, String) a]
    -> [Either (MediaType, String) (Headers h a)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Either (MediaType, String) a
      -> Either (MediaType, String) (Headers h a))
     -> [Either (MediaType, String) a]
     -> [Either (MediaType, String) (Headers h a)])
    -> ((a -> Headers h a)
        -> Either (MediaType, String) a
        -> Either (MediaType, String) (Headers h a))
    -> (a -> Headers h a)
    -> [Either (MediaType, String) a]
    -> [Either (MediaType, String) (Headers h a)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Headers h a)
    -> Either (MediaType, String) a
    -> Either (MediaType, String) (Headers h a)
    forall a b.
    (a -> b)
    -> Either (MediaType, String) a -> Either (MediaType, String) b
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    fmap) a -> Headers h a
    setHeaders ([Either (MediaType, String) a]
     -> [Either (MediaType, String) (Headers h a)])
    -> (Proxy cts -> [Either (MediaType, String) a])
    -> Proxy cts
    -> [Either (MediaType, String) (Headers h a)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Seq Header
    -> ByteString -> Proxy cts -> [Either (MediaType, String) a]
    forall (cts :: [Type]) a.
    UnrenderResponse cts a =>
    Seq Header
    -> ByteString -> Proxy cts -> [Either (MediaType, String) a]
    unrenderResponse Seq Header
    hs ByteString
    body
        where
          setHeaders :: a -> Headers h a
          setHeaders :: a -> Headers h a
    setHeaders a
    x = a -> HList h -> Headers h a
    forall (ls :: [Type]) a. a -> HList ls -> Headers ls a
    Headers a
    x ([Header] -> HList h
    forall (hs :: [Type]). BuildHeadersTo hs => [Header] -> HList hs
    buildHeadersTo (Seq Header -> [Header]
    forall a. Seq a -> [a]
    forall (t :: Type -> Type) a. Foldable t => t a -> [a]
    toList Seq Header
    hs))

    instance {-# OVERLAPPING #-} UnrenderResponse cts a
      => UnrenderResponse cts (WithStatus n a) where
      unrenderResponse :: Seq Header
    -> ByteString
    -> Proxy cts
    -> [Either (MediaType, String) (WithStatus n a)]
    unrenderResponse Seq Header
    hs ByteString
    body = ((Either (MediaType, String) a
     -> Either (MediaType, String) (WithStatus n a))
    -> [Either (MediaType, String) a]
    -> [Either (MediaType, String) (WithStatus n a)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Either (MediaType, String) a
      -> Either (MediaType, String) (WithStatus n a))
     -> [Either (MediaType, String) a]
     -> [Either (MediaType, String) (WithStatus n a)])
    -> ((a -> WithStatus n a)
        -> Either (MediaType, String) a
        -> Either (MediaType, String) (WithStatus n a))
    -> (a -> WithStatus n a)
    -> [Either (MediaType, String) a]
    -> [Either (MediaType, String) (WithStatus n a)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> WithStatus n a)
    -> Either (MediaType, String) a
    -> Either (MediaType, String) (WithStatus n a)
    forall a b.
    (a -> b)
    -> Either (MediaType, String) a -> Either (MediaType, String) b
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    fmap) a -> WithStatus n a
    forall (k :: Nat) a. a -> WithStatus k a
    WithStatus ([Either (MediaType, String) a]
     -> [Either (MediaType, String) (WithStatus n a)])
    -> (Proxy cts -> [Either (MediaType, String) a])
    -> Proxy cts
    -> [Either (MediaType, String) (WithStatus n a)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Seq Header
    -> ByteString -> Proxy cts -> [Either (MediaType, String) a]
    forall (cts :: [Type]) a.
    UnrenderResponse cts a =>
    Seq Header
    -> ByteString -> Proxy cts -> [Either (MediaType, String) a]
    unrenderResponse Seq Header
    hs ByteString
    body

    instance {-# OVERLAPPING #-}
      ( RunClient m,
        contentTypes ~ (contentType ': otherContentTypes),
        -- ('otherContentTypes' should be '_', but even -XPartialTypeSignatures does not seem
        -- allow this in instance types as of 8.8.3.)
        as ~ (a ': as'),
        AllMime contentTypes,
        ReflectMethod method,
        All (UnrenderResponse contentTypes) as,
        All HasStatus as, HasStatuses as',
        Unique (Statuses as)
      ) =>
      HasClient m (UVerb method contentTypes as)
      where
      type Client m (UVerb method contentTypes as) = m (Union as)

      clientWithRoute :: Proxy m
    -> Proxy (UVerb method contentTypes as)
    -> Request
    -> Client m (UVerb method contentTypes as)
    clientWithRoute Proxy m
    _ Proxy (UVerb method contentTypes as)
    _ Request
    request = do
        let accept :: Seq MediaType
    accept = [MediaType] -> Seq MediaType
    forall a. [a] -> Seq a
    Seq.fromList ([MediaType] -> Seq MediaType)
    -> (Proxy contentTypes -> [MediaType])
    -> Proxy contentTypes
    -> Seq MediaType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy contentTypes -> [MediaType]
    forall (list :: [Type]). AllMime list => Proxy list -> [MediaType]
    allMime (Proxy contentTypes -> Seq MediaType)
    -> Proxy contentTypes -> Seq MediaType
    forall a b. (a -> b) -> a -> b
    $ forall (t :: [Type]). Proxy t
    forall {k} (t :: k). Proxy t
    Proxy @contentTypes
            -- offering to accept all mime types listed in the api gives best compatibility.  eg.,
            -- we might not own the server implementation, and the server may choose to support
            -- only part of the api.

            method :: Method
    method = Proxy method -> Method
    forall {k} (a :: k). ReflectMethod a => Proxy a -> Method
    reflectMethod (Proxy method -> Method) -> Proxy method -> Method
    forall a b. (a -> b) -> a -> b
    $ forall {k} (t :: k). Proxy t
    forall (t :: StdMethod). Proxy t
    Proxy @method
            acceptStatus :: [Status]
    acceptStatus = Proxy as -> [Status]
    forall (as :: [Type]). HasStatuses as => Proxy as -> [Status]
    statuses (forall (t :: [Type]). Proxy t
    forall {k} (t :: k). Proxy t
    Proxy @as)
        response :: Response
    response@Response{responseBody :: forall a. ResponseF a -> a
    responseBody=ByteString
    body, responseStatusCode :: forall a. ResponseF a -> Status
    responseStatusCode=Status
    status, responseHeaders :: forall a. ResponseF a -> Seq Header
    responseHeaders=Seq Header
    headers}
          <- Maybe [Status] -> Request -> m Response
    forall (m :: Type -> Type).
    RunClient m =>
    Maybe [Status] -> Request -> m Response
    runRequestAcceptStatus ([Status] -> Maybe [Status]
    forall a. a -> Maybe a
    Just [Status]
    acceptStatus) (Request
    request {requestMethod = method, requestAccept = accept})
        MediaType
    responseContentType <- Response -> m MediaType
    forall (m :: Type -> Type). RunClient m => Response -> m MediaType
    checkContentTypeHeader Response
    response
        Bool -> m () -> m ()
    forall (f :: Type -> Type). Applicative f => Bool -> f () -> f ()
    unless ((MediaType -> Bool) -> Seq MediaType -> Bool
    forall (t :: Type -> Type) a.
    Foldable t =>
    (a -> Bool) -> t a -> Bool
    any (MediaType -> MediaType -> Bool
    forall a. Accept a => a -> a -> Bool
    matches MediaType
    responseContentType) Seq MediaType
    accept) (m () -> m ()) -> m () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
          ClientError -> m ()
    forall a. ClientError -> m a
    forall (m :: Type -> Type) a. RunClient m => ClientError -> m a
    throwClientError (ClientError -> m ()) -> ClientError -> m ()
    forall a b. (a -> b) -> a -> b
    $ MediaType -> Response -> ClientError
    UnsupportedContentType MediaType
    responseContentType Response
    response

        let res :: Either [ClientParseError] (Union (a : as'))
    res = Status
    -> NP ([] :.: Either (MediaType, String)) (a : as')
    -> Either [ClientParseError] (Union (a : as'))
    forall (xs :: [Type]).
    All HasStatus xs =>
    Status
    -> NP ([] :.: Either (MediaType, String)) xs
    -> Either [ClientParseError] (Union xs)
    tryParsers Status
    status (NP ([] :.: Either (MediaType, String)) (a : as')
     -> Either [ClientParseError] (Union (a : as')))
    -> NP ([] :.: Either (MediaType, String)) (a : as')
    -> Either [ClientParseError] (Union (a : as'))
    forall a b. (a -> b) -> a -> b
    $ Proxy contentTypes
    -> Seq Header
    -> ByteString
    -> NP ([] :.: Either (MediaType, String)) (a : as')
    forall (cts :: [Type]) (xs :: [Type]).
    All (UnrenderResponse cts) xs =>
    Proxy cts
    -> Seq Header
    -> ByteString
    -> NP ([] :.: Either (MediaType, String)) xs
    mimeUnrenders (forall (t :: [Type]). Proxy t
    forall {k} (t :: k). Proxy t
    Proxy @contentTypes) Seq Header
    headers ByteString
    body
        case Either [ClientParseError] (Union (a : as'))
    res of
          Left [ClientParseError]
    errors -> ClientError -> m (Union (a : as'))
    forall a. ClientError -> m a
    forall (m :: Type -> Type) a. RunClient m => ClientError -> m a
    throwClientError (ClientError -> m (Union (a : as')))
    -> ClientError -> m (Union (a : as'))
    forall a b. (a -> b) -> a -> b
    $ Text -> Response -> ClientError
    DecodeFailure (String -> Text
    T.pack ([ClientParseError] -> String
    forall a. Show a => a -> String
    show [ClientParseError]
    errors)) Response
    response
          Right Union (a : as')
    x -> Union (a : as') -> m (Union (a : as'))
    forall a. a -> m a
    forall (m :: Type -> Type) a. Monad m => a -> m a
    return Union (a : as')
    x
        where
          -- | Given a list of parsers of 'mkres', returns the first one that succeeds and all the
          -- failures it encountered along the way
          -- TODO; better name, rewrite haddocs.
          tryParsers :: forall xs. All HasStatus xs => Status -> NP ([] :.: Either (MediaType, String)) xs -> Either [ClientParseError] (Union xs)
          tryParsers :: forall (xs :: [Type]).
    All HasStatus xs =>
    Status
    -> NP ([] :.: Either (MediaType, String)) xs
    -> Either [ClientParseError] (Union xs)
    tryParsers Status
    _ NP ([] :.: Either (MediaType, String)) xs
    Nil = [ClientParseError] -> Either [ClientParseError] (Union xs)
    forall a b. a -> Either a b
    Left [ClientParseError
    ClientNoMatchingStatus]
          tryParsers Status
    status (Comp [Either (MediaType, String) x]
    x :* NP ([] :.: Either (MediaType, String)) xs
    xs)
            | Status
    status Status -> Status -> Bool
    forall a. Eq a => a -> a -> Bool
    == (:.:) [] (Either (MediaType, String)) x -> Status
    forall a (proxy :: Type -> Type). HasStatus a => proxy a -> Status
    statusOf ([Either (MediaType, String) x]
    -> (:.:) [] (Either (MediaType, String)) x
    forall l k (f :: l -> Type) (g :: k -> l) (p :: k).
    f (g p) -> (:.:) f g p
    Comp [Either (MediaType, String) x]
    x) =
              case [Either (MediaType, String) x] -> ([(MediaType, String)], [x])
    forall a b. [Either a b] -> ([a], [b])
    partitionEithers [Either (MediaType, String) x]
    x of
                ([(MediaType, String)]
    err', []) -> (((MediaType, String) -> ClientParseError)
    -> [(MediaType, String)] -> [ClientParseError]
    forall a b. (a -> b) -> [a] -> [b]
    map ((MediaType -> String -> ClientParseError)
    -> (MediaType, String) -> ClientParseError
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry MediaType -> String -> ClientParseError
    ClientParseError) [(MediaType, String)]
    err' [ClientParseError] -> [ClientParseError] -> [ClientParseError]
    forall a. [a] -> [a] -> [a]
    ++) ([ClientParseError] -> [ClientParseError])
    -> (NS I xs -> Union xs)
    -> Either [ClientParseError] (NS I xs)
    -> Either [ClientParseError] (Union xs)
    forall b c b' c'.
    (b -> c) -> (b' -> c') -> Either b b' -> Either c c'
    forall (a :: Type -> Type -> Type) b c b' c'.
    ArrowChoice a =>
    a b c -> a b' c' -> a (Either b b') (Either c c')
    +++ NS I xs -> Union xs
    NS I xs -> NS I (x : xs)
    forall {k} (a :: k -> Type) (xs :: [k]) (x :: k).
    NS a xs -> NS a (x : xs)
    S (Either [ClientParseError] (NS I xs)
     -> Either [ClientParseError] (Union xs))
    -> Either [ClientParseError] (NS I xs)
    -> Either [ClientParseError] (Union xs)
    forall a b. (a -> b) -> a -> b
    $ Status
    -> NP ([] :.: Either (MediaType, String)) xs
    -> Either [ClientParseError] (NS I xs)
    forall (xs :: [Type]).
    All HasStatus xs =>
    Status
    -> NP ([] :.: Either (MediaType, String)) xs
    -> Either [ClientParseError] (Union xs)
    tryParsers Status
    status NP ([] :.: Either (MediaType, String)) xs
    xs
                ([(MediaType, String)]
    _, (x
    res : [x]
    _)) -> Union xs -> Either [ClientParseError] (Union xs)
    forall a b. b -> Either a b
    Right (Union xs -> Either [ClientParseError] (Union xs))
    -> (x -> Union xs) -> x -> Either [ClientParseError] (Union xs)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . I x -> Union xs
    forall {k} (x :: k) (xs :: [k]) (f :: k -> Type).
    UElem x xs =>
    f x -> NS f xs
    forall (f :: Type -> Type). f x -> NS f xs
    inject (I x -> Union xs) -> (x -> I x) -> x -> Union xs
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . x -> I x
    forall a. a -> I a
    I (x -> Either [ClientParseError] (Union xs))
    -> x -> Either [ClientParseError] (Union xs)
    forall a b. (a -> b) -> a -> b
    $ x
    res
            | Bool
    otherwise = -- no reason to parse in the first place. This ain't the one we're looking for
              (ClientParseError
    ClientStatusMismatch ClientParseError -> [ClientParseError] -> [ClientParseError]
    forall a. a -> [a] -> [a]
    :) ([ClientParseError] -> [ClientParseError])
    -> (NS I xs -> Union xs)
    -> Either [ClientParseError] (NS I xs)
    -> Either [ClientParseError] (Union xs)
    forall b c b' c'.
    (b -> c) -> (b' -> c') -> Either b b' -> Either c c'
    forall (a :: Type -> Type -> Type) b c b' c'.
    ArrowChoice a =>
    a b c -> a b' c' -> a (Either b b') (Either c c')
    +++ NS I xs -> Union xs
    NS I xs -> NS I (x : xs)
    forall {k} (a :: k -> Type) (xs :: [k]) (x :: k).
    NS a xs -> NS a (x : xs)
    S (Either [ClientParseError] (NS I xs)
     -> Either [ClientParseError] (Union xs))
    -> Either [ClientParseError] (NS I xs)
    -> Either [ClientParseError] (Union xs)
    forall a b. (a -> b) -> a -> b
    $ Status
    -> NP ([] :.: Either (MediaType, String)) xs
    -> Either [ClientParseError] (NS I xs)
    forall (xs :: [Type]).
    All HasStatus xs =>
    Status
    -> NP ([] :.: Either (MediaType, String)) xs
    -> Either [ClientParseError] (Union xs)
    tryParsers Status
    status NP ([] :.: Either (MediaType, String)) xs
    xs

          -- | Given a list of types, parses the given response body as each type
          mimeUnrenders ::
            forall cts xs.
            All (UnrenderResponse cts) xs =>
            Proxy cts ->
            Seq.Seq H.Header ->
            BSL.ByteString ->
            NP ([] :.: Either (MediaType, String)) xs
          mimeUnrenders :: forall (cts :: [Type]) (xs :: [Type]).
    All (UnrenderResponse cts) xs =>
    Proxy cts
    -> Seq Header
    -> ByteString
    -> NP ([] :.: Either (MediaType, String)) xs
    mimeUnrenders Proxy cts
    ctp Seq Header
    headers ByteString
    body = Proxy (UnrenderResponse cts)
    -> (forall a.
        UnrenderResponse cts a =>
        (:.:) [] (Either (MediaType, String)) a)
    -> NP ([] :.: Either (MediaType, String)) xs
    forall {k} (c :: k -> Constraint) (xs :: [k])
           (proxy :: (k -> Constraint) -> Type) (f :: k -> Type).
    All c xs =>
    proxy c -> (forall (a :: k). c a => f a) -> NP f xs
    cpure_NP
            (forall {k} (t :: k). Proxy t
    forall (t :: Type -> Constraint). Proxy t
    Proxy @(UnrenderResponse cts))
            ([Either (MediaType, String) a]
    -> (:.:) [] (Either (MediaType, String)) a
    forall l k (f :: l -> Type) (g :: k -> l) (p :: k).
    f (g p) -> (:.:) f g p
    Comp ([Either (MediaType, String) a]
     -> (:.:) [] (Either (MediaType, String)) a)
    -> (Proxy cts -> [Either (MediaType, String) a])
    -> Proxy cts
    -> (:.:) [] (Either (MediaType, String)) a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Seq Header
    -> ByteString -> Proxy cts -> [Either (MediaType, String) a]
    forall (cts :: [Type]) a.
    UnrenderResponse cts a =>
    Seq Header
    -> ByteString -> Proxy cts -> [Either (MediaType, String) a]
    unrenderResponse Seq Header
    headers ByteString
    body (Proxy cts -> (:.:) [] (Either (MediaType, String)) a)
    -> Proxy cts -> (:.:) [] (Either (MediaType, String)) a
    forall a b. (a -> b) -> a -> b
    $ Proxy cts
    ctp)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (UVerb method contentTypes as)
    -> (forall x. mon x -> mon' x)
    -> Client mon (UVerb method contentTypes as)
    -> Client mon' (UVerb method contentTypes as)
    hoistClientMonad Proxy m
    _ Proxy (UVerb method contentTypes as)
    _ forall x. mon x -> mon' x
    nt Client mon (UVerb method contentTypes as)
    s = mon (Union (a : as')) -> mon' (Union (a : as'))
    forall x. mon x -> mon' x
    nt mon (Union (a : as'))
    Client mon (UVerb method contentTypes as)
    s

    instance {-# OVERLAPPABLE #-}
      ( RunStreamingClient m, MimeUnrender ct chunk, ReflectMethod method,
        FramingUnrender framing, FromSourceIO chunk a
      ) => HasClient m (Stream method status framing ct a) where

      type Client m (Stream method status framing ct a) = m a

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Stream method status framing ct a)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Stream method status framing ct a)
    -> Client mon' (Stream method status framing ct a)
    hoistClientMonad Proxy m
    _ Proxy (Stream method status framing ct a)
    _ forall x. mon x -> mon' x
    f Client mon (Stream method status framing ct a)
    ma = mon a -> mon' a
    forall x. mon x -> mon' x
    f mon a
    Client mon (Stream method status framing ct a)
    ma

      clientWithRoute :: Proxy m
    -> Proxy (Stream method status framing ct a)
    -> Request
    -> Client m (Stream method status framing ct a)
    clientWithRoute Proxy m
    _pm Proxy (Stream method status framing ct a)
    Proxy Request
    req = Request -> (StreamingResponse -> IO a) -> m a
    forall a. Request -> (StreamingResponse -> IO a) -> m a
    forall (m :: Type -> Type) a.
    RunStreamingClient m =>
    Request -> (StreamingResponse -> IO a) -> m a
    withStreamingRequest Request
    req' ((StreamingResponse -> IO a) -> m a)
    -> (StreamingResponse -> IO a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \Response{responseBody :: forall a. ResponseF a -> a
    responseBody=SourceIO Method
    body} -> do
          let mimeUnrender' :: ByteString -> Either String chunk
    mimeUnrender'    = Proxy ct -> ByteString -> Either String chunk
    forall {k} (ctype :: k) a.
    MimeUnrender ctype a =>
    Proxy ctype -> ByteString -> Either String a
    mimeUnrender (Proxy ct
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy ct) :: BSL.ByteString -> Either String chunk
              framingUnrender' :: SourceIO Method -> SourceT IO chunk
    framingUnrender' = Proxy framing
    -> (ByteString -> Either String chunk)
    -> SourceIO Method
    -> SourceT IO chunk
    forall {k} (strategy :: k) (m :: Type -> Type) a.
    (FramingUnrender strategy, Monad m) =>
    Proxy strategy
    -> (ByteString -> Either String a)
    -> SourceT m Method
    -> SourceT m a
    forall (m :: Type -> Type) a.
    Monad m =>
    Proxy framing
    -> (ByteString -> Either String a)
    -> SourceT m Method
    -> SourceT m a
    framingUnrender (Proxy framing
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy framing) ByteString -> Either String chunk
    mimeUnrender'
          SourceT IO chunk -> IO a
    forall chunk a. FromSourceIO chunk a => SourceIO chunk -> IO a
    fromSourceIO (SourceT IO chunk -> IO a) -> SourceT IO chunk -> IO a
    forall a b. (a -> b) -> a -> b
    $ SourceIO Method -> SourceT IO chunk
    framingUnrender' SourceIO Method
    body
        where
          req' :: Request
    req' = Request
    req
              { requestAccept = fromList [contentType (Proxy :: Proxy ct)]
              , requestMethod = reflectMethod (Proxy :: Proxy method)
              }

    instance {-# OVERLAPPING #-}
      ( RunStreamingClient m, MimeUnrender ct chunk, ReflectMethod method,
        FramingUnrender framing, FromSourceIO chunk a,
        BuildHeadersTo hs
      ) => HasClient m (Stream method status framing ct (Headers hs a)) where

      type Client m (Stream method status framing ct (Headers hs a)) = m (Headers hs a)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Stream method status framing ct (Headers hs a))
    -> (forall x. mon x -> mon' x)
    -> Client mon (Stream method status framing ct (Headers hs a))
    -> Client mon' (Stream method status framing ct (Headers hs a))
    hoistClientMonad Proxy m
    _ Proxy (Stream method status framing ct (Headers hs a))
    _ forall x. mon x -> mon' x
    f Client mon (Stream method status framing ct (Headers hs a))
    ma = mon (Headers hs a) -> mon' (Headers hs a)
    forall x. mon x -> mon' x
    f mon (Headers hs a)
    Client mon (Stream method status framing ct (Headers hs a))
    ma

      clientWithRoute :: Proxy m
    -> Proxy (Stream method status framing ct (Headers hs a))
    -> Request
    -> Client m (Stream method status framing ct (Headers hs a))
    clientWithRoute Proxy m
    _pm Proxy (Stream method status framing ct (Headers hs a))
    Proxy Request
    req = Request
    -> (StreamingResponse -> IO (Headers hs a)) -> m (Headers hs a)
    forall a. Request -> (StreamingResponse -> IO a) -> m a
    forall (m :: Type -> Type) a.
    RunStreamingClient m =>
    Request -> (StreamingResponse -> IO a) -> m a
    withStreamingRequest Request
    req' ((StreamingResponse -> IO (Headers hs a)) -> m (Headers hs a))
    -> (StreamingResponse -> IO (Headers hs a)) -> m (Headers hs a)
    forall a b. (a -> b) -> a -> b
    $
        \Response{responseBody :: forall a. ResponseF a -> a
    responseBody=SourceIO Method
    body, responseHeaders :: forall a. ResponseF a -> Seq Header
    responseHeaders=Seq Header
    headers} -> do
          let mimeUnrender' :: ByteString -> Either String chunk
    mimeUnrender'    = Proxy ct -> ByteString -> Either String chunk
    forall {k} (ctype :: k) a.
    MimeUnrender ctype a =>
    Proxy ctype -> ByteString -> Either String a
    mimeUnrender (Proxy ct
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy ct) :: BSL.ByteString -> Either String chunk
              framingUnrender' :: SourceIO Method -> SourceT IO chunk
    framingUnrender' = Proxy framing
    -> (ByteString -> Either String chunk)
    -> SourceIO Method
    -> SourceT IO chunk
    forall {k} (strategy :: k) (m :: Type -> Type) a.
    (FramingUnrender strategy, Monad m) =>
    Proxy strategy
    -> (ByteString -> Either String a)
    -> SourceT m Method
    -> SourceT m a
    forall (m :: Type -> Type) a.
    Monad m =>
    Proxy framing
    -> (ByteString -> Either String a)
    -> SourceT m Method
    -> SourceT m a
    framingUnrender (Proxy framing
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy framing) ByteString -> Either String chunk
    mimeUnrender'
          a
    val <- SourceT IO chunk -> IO a
    forall chunk a. FromSourceIO chunk a => SourceIO chunk -> IO a
    fromSourceIO (SourceT IO chunk -> IO a) -> SourceT IO chunk -> IO a
    forall a b. (a -> b) -> a -> b
    $ SourceIO Method -> SourceT IO chunk
    framingUnrender' SourceIO Method
    body
          return $ Headers
            { getResponse :: a
    getResponse = a
    val
            , getHeadersHList :: HList hs
    getHeadersHList = [Header] -> HList hs
    forall (hs :: [Type]). BuildHeadersTo hs => [Header] -> HList hs
    buildHeadersTo ([Header] -> HList hs) -> [Header] -> HList hs
    forall a b. (a -> b) -> a -> b
    $ Seq Header -> [Header]
    forall a. Seq a -> [a]
    forall (t :: Type -> Type) a. Foldable t => t a -> [a]
    toList Seq Header
    headers
            }

        where
          req' :: Request
    req' = Request
    req
              { requestAccept = fromList [contentType (Proxy :: Proxy ct)]
              , requestMethod = reflectMethod (Proxy :: Proxy method)
              }

    type SseClientDelegate method status =
      Stream method status NoFraming EventStream

    instance
      ( RunClient m
      , HasClient m (SseClientDelegate method status (EventMessageStreamT IO))
      )
      => HasClient m (ServerSentEvents' method status 'RawEvent EventMessage) where
        type Client m (ServerSentEvents' method status 'RawEvent EventMessage) =
          Client m (SseClientDelegate method status (EventMessageStreamT IO))

        hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (ServerSentEvents' method status 'RawEvent EventMessage)
    -> (forall x. mon x -> mon' x)
    -> Client
         mon (ServerSentEvents' method status 'RawEvent EventMessage)
    -> Client
         mon' (ServerSentEvents' method status 'RawEvent EventMessage)
    hoistClientMonad Proxy m
    p Proxy (ServerSentEvents' method status 'RawEvent EventMessage)
    _ =
          Proxy m
    -> Proxy (SseClientDelegate method status (EventMessageStreamT IO))
    -> (forall x. mon x -> mon' x)
    -> Client
         mon (SseClientDelegate method status (EventMessageStreamT IO))
    -> Client
         mon' (SseClientDelegate method status (EventMessageStreamT IO))
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (SseClientDelegate method status (EventMessageStreamT IO))
    -> (forall x. mon x -> mon' x)
    -> Client
         mon (SseClientDelegate method status (EventMessageStreamT IO))
    -> Client
         mon' (SseClientDelegate method status (EventMessageStreamT IO))
    hoistClientMonad
            Proxy m
    p
            (Proxy (SseClientDelegate method status (EventMessageStreamT IO))
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy (SseClientDelegate method status (EventMessageStreamT IO)))

        clientWithRoute :: Proxy m
    -> Proxy (ServerSentEvents' method status 'RawEvent EventMessage)
    -> Request
    -> Client
         m (ServerSentEvents' method status 'RawEvent EventMessage)
    clientWithRoute Proxy m
    p Proxy (ServerSentEvents' method status 'RawEvent EventMessage)
    _ =
          Proxy m
    -> Proxy (SseClientDelegate method status (EventMessageStreamT IO))
    -> Request
    -> Client
         m (SseClientDelegate method status (EventMessageStreamT IO))
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute
            Proxy m
    p
            (Proxy (SseClientDelegate method status (EventMessageStreamT IO))
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy (SseClientDelegate method status (EventMessageStreamT IO)))

    instance
      ( RunClient m
      , HasClient m (SseClientDelegate method status (EventStreamT IO))
      )
      => HasClient m (ServerSentEvents' method status 'RawEvent (Event a)) where
        type Client m (ServerSentEvents' method status 'RawEvent (Event a)) =
          Client m (SseClientDelegate method status (EventStreamT IO))

        hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (ServerSentEvents' method status 'RawEvent (Event a))
    -> (forall x. mon x -> mon' x)
    -> Client mon (ServerSentEvents' method status 'RawEvent (Event a))
    -> Client
         mon' (ServerSentEvents' method status 'RawEvent (Event a))
    hoistClientMonad Proxy m
    p Proxy (ServerSentEvents' method status 'RawEvent (Event a))
    _ =
          Proxy m
    -> Proxy (SseClientDelegate method status (EventStreamT IO))
    -> (forall x. mon x -> mon' x)
    -> Client mon (SseClientDelegate method status (EventStreamT IO))
    -> Client mon' (SseClientDelegate method status (EventStreamT IO))
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (SseClientDelegate method status (EventStreamT IO))
    -> (forall x. mon x -> mon' x)
    -> Client mon (SseClientDelegate method status (EventStreamT IO))
    -> Client mon' (SseClientDelegate method status (EventStreamT IO))
    hoistClientMonad
            Proxy m
    p
            (Proxy (SseClientDelegate method status (EventStreamT IO))
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy (SseClientDelegate method status (EventStreamT IO)))

        clientWithRoute :: Proxy m
    -> Proxy (ServerSentEvents' method status 'RawEvent (Event a))
    -> Request
    -> Client m (ServerSentEvents' method status 'RawEvent (Event a))
    clientWithRoute Proxy m
    p Proxy (ServerSentEvents' method status 'RawEvent (Event a))
    _ =
          Proxy m
    -> Proxy (SseClientDelegate method status (EventStreamT IO))
    -> Request
    -> Client m (SseClientDelegate method status (EventStreamT IO))
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute
            Proxy m
    p
            (Proxy (SseClientDelegate method status (EventStreamT IO))
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy (SseClientDelegate method status (EventStreamT IO)))

    instance
      ( RunClient m
      , HasClient m (SseClientDelegate method status (JsonEventStreamT IO a))
      )
      => HasClient m (ServerSentEvents' method status 'JsonEvent a) where
        type Client m (ServerSentEvents' method status 'JsonEvent a) =
          Client m (SseClientDelegate method status (JsonEventStreamT IO a))

        hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (ServerSentEvents' method status 'JsonEvent a)
    -> (forall x. mon x -> mon' x)
    -> Client mon (ServerSentEvents' method status 'JsonEvent a)
    -> Client mon' (ServerSentEvents' method status 'JsonEvent a)
    hoistClientMonad Proxy m
    p Proxy (ServerSentEvents' method status 'JsonEvent a)
    _ =
          Proxy m
    -> Proxy (SseClientDelegate method status (JsonEventStreamT IO a))
    -> (forall x. mon x -> mon' x)
    -> Client
         mon (SseClientDelegate method status (JsonEventStreamT IO a))
    -> Client
         mon' (SseClientDelegate method status (JsonEventStreamT IO a))
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (SseClientDelegate method status (JsonEventStreamT IO a))
    -> (forall x. mon x -> mon' x)
    -> Client
         mon (SseClientDelegate method status (JsonEventStreamT IO a))
    -> Client
         mon' (SseClientDelegate method status (JsonEventStreamT IO a))
    hoistClientMonad
            Proxy m
    p
            (Proxy (SseClientDelegate method status (JsonEventStreamT IO a))
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy (SseClientDelegate method status (JsonEventStreamT IO a)))

        clientWithRoute :: Proxy m
    -> Proxy (ServerSentEvents' method status 'JsonEvent a)
    -> Request
    -> Client m (ServerSentEvents' method status 'JsonEvent a)
    clientWithRoute Proxy m
    p Proxy (ServerSentEvents' method status 'JsonEvent a)
    _ =
          Proxy m
    -> Proxy (SseClientDelegate method status (JsonEventStreamT IO a))
    -> Request
    -> Client
         m (SseClientDelegate method status (JsonEventStreamT IO a))
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute
            Proxy m
    p
            (Proxy (SseClientDelegate method status (JsonEventStreamT IO a))
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy (SseClientDelegate method status (JsonEventStreamT IO a)))

    -- | If you use a 'Header' in one of your endpoints in your API,
    -- the corresponding querying function will automatically take
    -- an additional argument of the type specified by your 'Header',
    -- wrapped in Maybe.
    --
    -- That function will take care of encoding this argument as Text
    -- in the request headers.
    --
    -- All you need is for your type to have a 'ToHttpApiData' 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
    instance (KnownSymbol sym, ToHttpApiData a, HasClient m api, SBoolI (FoldRequired mods))
          => HasClient m (Header' mods sym a :> api) where

      type Client m (Header' mods sym a :> api) =
        RequiredArgument mods a -> Client m api

      clientWithRoute :: Proxy m
    -> Proxy (Header' mods sym a :> api)
    -> Request
    -> Client m (Header' mods sym a :> api)
    clientWithRoute Proxy m
    pm Proxy (Header' mods sym a :> api)
    Proxy Request
    req If (FoldRequired mods) a (Maybe a)
    mval =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) (Request -> Client m api) -> Request -> Client m api
    forall a b. (a -> b) -> a -> b
    $ Proxy mods
    -> (a -> Request)
    -> (Maybe a -> Request)
    -> If (FoldRequired mods) a (Maybe a)
    -> Request
    forall (mods :: [Type]) a r.
    SBoolI (FoldRequired mods) =>
    Proxy mods
    -> (a -> r) -> (Maybe a -> r) -> RequiredArgument mods a -> r
    foldRequiredArgument
          (Proxy mods
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy mods) a -> Request
    add (Request -> (a -> Request) -> Maybe a -> Request
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Request
    req a -> Request
    add) If (FoldRequired mods) a (Maybe a)
    mval
        where
          hname :: HeaderName
    hname = String -> HeaderName
    forall a. IsString a => String -> a
    fromString (String -> HeaderName) -> String -> HeaderName
    forall a b. (a -> b) -> a -> b
    $ Proxy sym -> String
    forall (n :: Symbol) (proxy :: Symbol -> Type).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy sym
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy sym)

          add :: a -> Request
          add :: a -> Request
    add a
    value = HeaderName -> a -> Request -> Request
    forall a. ToHttpApiData a => HeaderName -> a -> Request -> Request
    addHeader HeaderName
    hname a
    value Request
    req

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Header' mods sym a :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Header' mods sym a :> api)
    -> Client mon' (Header' mods sym a :> api)
    hoistClientMonad Proxy m
    pm Proxy (Header' mods sym a :> api)
    _ forall x. mon x -> mon' x
    f Client mon (Header' mods sym a :> api)
    cl = \If (FoldRequired mods) a (Maybe a)
    arg ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (Header' mods sym a :> api)
    If (FoldRequired mods) a (Maybe a) -> Client mon api
    cl If (FoldRequired mods) a (Maybe a)
    arg)

    instance (KnownSymbol sym, HasClient m api) => HasClient m (Host sym :> api) where
      type Client m (Host sym :> api) = Client m api

      clientWithRoute :: Proxy m
    -> Proxy (Host sym :> api) -> Request -> Client m (Host sym :> api)
    clientWithRoute Proxy m
    pm Proxy (Host sym :> api)
    Proxy Request
    req =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) (Request -> Client m api) -> Request -> Client m api
    forall a b. (a -> b) -> a -> b
    $
          HeaderName -> String -> Request -> Request
    forall a. ToHttpApiData a => HeaderName -> a -> Request -> Request
    addHeader HeaderName
    "Host" (Proxy sym -> String
    forall (n :: Symbol) (proxy :: Symbol -> Type).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy sym
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy sym)) Request
    req

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Host sym :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Host sym :> api)
    -> Client mon' (Host sym :> api)
    hoistClientMonad Proxy m
    pm Proxy (Host sym :> api)
    _ = Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)

    -- | Using a 'HttpVersion' combinator in your API doesn't affect the client
    -- functions.
    instance HasClient m api
      => HasClient m (HttpVersion :> api) where

      type Client m (HttpVersion :> api) =
        Client m api

      clientWithRoute :: Proxy m
    -> Proxy (HttpVersion :> api)
    -> Request
    -> Client m (HttpVersion :> api)
    clientWithRoute Proxy m
    pm Proxy (HttpVersion :> api)
    Proxy =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (HttpVersion :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (HttpVersion :> api)
    -> Client mon' (HttpVersion :> api)
    hoistClientMonad Proxy m
    pm Proxy (HttpVersion :> api)
    _ forall x. mon x -> mon' x
    f Client mon (HttpVersion :> api)
    cl = Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon api
    Client mon (HttpVersion :> api)
    cl

    -- | Ignore @'Summary'@ in client functions.
    instance HasClient m api => HasClient m (Summary desc :> api) where
      type Client m (Summary desc :> api) = Client m api

      clientWithRoute :: Proxy m
    -> Proxy (Summary desc :> api)
    -> Request
    -> Client m (Summary desc :> api)
    clientWithRoute Proxy m
    pm Proxy (Summary desc :> api)
    _ = Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Summary desc :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Summary desc :> api)
    -> Client mon' (Summary desc :> api)
    hoistClientMonad Proxy m
    pm Proxy (Summary desc :> api)
    _ forall x. mon x -> mon' x
    f Client mon (Summary desc :> api)
    cl = Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon api
    Client mon (Summary desc :> api)
    cl

    -- | Ignore @'Description'@ in client functions.
    instance HasClient m api => HasClient m (Description desc :> api) where
      type Client m (Description desc :> api) = Client m api

      clientWithRoute :: Proxy m
    -> Proxy (Description desc :> api)
    -> Request
    -> Client m (Description desc :> api)
    clientWithRoute Proxy m
    pm Proxy (Description desc :> api)
    _ = Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Description desc :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Description desc :> api)
    -> Client mon' (Description desc :> api)
    hoistClientMonad Proxy m
    pm Proxy (Description desc :> api)
    _ forall x. mon x -> mon' x
    f Client mon (Description desc :> api)
    cl = Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon api
    Client mon (Description desc :> api)
    cl

    -- | If you use a 'QueryParam' in one of your endpoints in your API,
    -- the corresponding querying function will automatically take
    -- an additional argument of the type specified by your 'QueryParam',
    -- enclosed in Maybe.
    --
    -- If you give Nothing, nothing will be added to the query string.
    --
    -- If you give a non-'Nothing' value, this function will take care
    -- of inserting a textual representation of this value in the query string.
    --
    -- You can control how values for your type are turned into
    -- text by specifying a 'ToHttpApiData' 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 Asimov
    instance (KnownSymbol sym, ToHttpApiData a, HasClient m api, SBoolI (FoldRequired mods))
          => HasClient m (QueryParam' mods sym a :> api) where

      type Client m (QueryParam' mods sym a :> api) =
        RequiredArgument mods a -> Client m api

      -- if mparam = Nothing, we don't add it to the query string
      clientWithRoute :: Proxy m
    -> Proxy (QueryParam' mods sym a :> api)
    -> Request
    -> Client m (QueryParam' mods sym a :> api)
    clientWithRoute Proxy m
    pm Proxy (QueryParam' mods sym a :> api)
    Proxy Request
    req If (FoldRequired mods) a (Maybe a)
    mparam =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) (Request -> Client m api) -> Request -> Client m api
    forall a b. (a -> b) -> a -> b
    $ Proxy mods
    -> (a -> Request)
    -> (Maybe a -> Request)
    -> If (FoldRequired mods) a (Maybe a)
    -> Request
    forall (mods :: [Type]) a r.
    SBoolI (FoldRequired mods) =>
    Proxy mods
    -> (a -> r) -> (Maybe a -> r) -> RequiredArgument mods a -> r
    foldRequiredArgument
          (Proxy mods
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy mods) a -> Request
    add (Request -> (a -> Request) -> Maybe a -> Request
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Request
    req a -> Request
    add) If (FoldRequired mods) a (Maybe a)
    mparam
        where
          add :: a -> Request
          add :: a -> Request
    add a
    param = Text -> Maybe Method -> Request -> Request
    appendToQueryString Text
    pname (Method -> Maybe Method
    forall a. a -> Maybe a
    Just (Method -> Maybe Method) -> Method -> Maybe Method
    forall a b. (a -> b) -> a -> b
    $ a -> Method
    forall a. ToHttpApiData a => a -> Method
    encodeQueryParamValue a
    param) Request
    req

          pname :: Text
          pname :: Text
    pname  = String -> Text
    pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ Proxy sym -> String
    forall (n :: Symbol) (proxy :: Symbol -> Type).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy sym
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy sym)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (QueryParam' mods sym a :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (QueryParam' mods sym a :> api)
    -> Client mon' (QueryParam' mods sym a :> api)
    hoistClientMonad Proxy m
    pm Proxy (QueryParam' mods sym a :> api)
    _ forall x. mon x -> mon' x
    f Client mon (QueryParam' mods sym a :> api)
    cl = \If (FoldRequired mods) a (Maybe a)
    arg ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (QueryParam' mods sym a :> api)
    If (FoldRequired mods) a (Maybe a) -> Client mon api
    cl If (FoldRequired mods) a (Maybe a)
    arg)

    -- | If you use a 'QueryParams' 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 'QueryParams'.
    --
    -- If 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.
    --
    -- You can control how values for your type are turned into
    -- text by specifying a 'ToHttpApiData' instance for your type.
    --
    -- Example:
    --
    -- > type 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 Heinlein
    instance (KnownSymbol sym, ToHttpApiData a, HasClient m api)
          => HasClient m (QueryParams sym a :> api) where

      type Client m (QueryParams sym a :> api) =
        [a] -> Client m api

      clientWithRoute :: Proxy m
    -> Proxy (QueryParams sym a :> api)
    -> Request
    -> Client m (QueryParams sym a :> api)
    clientWithRoute Proxy m
    pm Proxy (QueryParams sym a :> api)
    Proxy Request
    req [a]
    paramlist =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)
                        ((Request -> Maybe Method -> Request)
    -> Request -> [Maybe Method] -> Request
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: Type -> Type) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    List.foldl' (\ Request
    req' -> Request -> (Method -> Request) -> Maybe Method -> Request
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Request
    req' ((Maybe Method -> Request -> Request)
    -> Request -> Maybe Method -> Request
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (Text -> Maybe Method -> Request -> Request
    appendToQueryString Text
    pname) Request
    req' (Maybe Method -> Request)
    -> (Method -> Maybe Method) -> Method -> Request
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Method -> Maybe Method
    forall a. a -> Maybe a
    Just))
                                Request
    req
                                [Maybe Method]
    paramlist'
                        )

        where pname :: Text
    pname = String -> Text
    pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ Proxy sym -> String
    forall (n :: Symbol) (proxy :: Symbol -> Type).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy sym
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy sym)
              paramlist' :: [Maybe Method]
    paramlist' = (a -> Maybe Method) -> [a] -> [Maybe Method]
    forall a b. (a -> b) -> [a] -> [b]
    map (Method -> Maybe Method
    forall a. a -> Maybe a
    Just (Method -> Maybe Method) -> (a -> Method) -> a -> Maybe Method
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Method
    forall a. ToHttpApiData a => a -> Method
    encodeQueryParamValue) [a]
    paramlist

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (QueryParams sym a :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (QueryParams sym a :> api)
    -> Client mon' (QueryParams sym a :> api)
    hoistClientMonad Proxy m
    pm Proxy (QueryParams sym a :> api)
    _ forall x. mon x -> mon' x
    f Client mon (QueryParams sym a :> api)
    cl = \[a]
    as ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (QueryParams sym a :> api)
    [a] -> Client mon api
    cl [a]
    as)

    -- | If you use a 'QueryFlag' in one of your endpoints in your API,
    -- the corresponding querying function will automatically take
    -- an additional 'Bool' argument.
    --
    -- If you give 'False', nothing will be added to the query string.
    --
    -- Otherwise, this function will insert a value-less query string
    -- parameter under the name associated to your 'QueryFlag'.
    --
    -- 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_ books
    instance (KnownSymbol sym, HasClient m api)
          => HasClient m (QueryFlag sym :> api) where

      type Client m (QueryFlag sym :> api) =
        Bool -> Client m api

      clientWithRoute :: Proxy m
    -> Proxy (QueryFlag sym :> api)
    -> Request
    -> Client m (QueryFlag sym :> api)
    clientWithRoute Proxy m
    pm Proxy (QueryFlag sym :> api)
    Proxy Request
    req Bool
    flag =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)
                        (if Bool
    flag
                           then Text -> Maybe Method -> Request -> Request
    appendToQueryString Text
    paramname Maybe Method
    forall a. Maybe a
    Nothing Request
    req
                           else Request
    req
                        )

        where paramname :: Text
    paramname = String -> Text
    pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ Proxy sym -> String
    forall (n :: Symbol) (proxy :: Symbol -> Type).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy sym
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy sym)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (QueryFlag sym :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (QueryFlag sym :> api)
    -> Client mon' (QueryFlag sym :> api)
    hoistClientMonad Proxy m
    pm Proxy (QueryFlag sym :> api)
    _ forall x. mon x -> mon' x
    f Client mon (QueryFlag sym :> api)
    cl = \Bool
    b ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (QueryFlag sym :> api)
    Bool -> Client mon api
    cl Bool
    b)

    instance (HasClient m api)
          => HasClient m (QueryString :> api) where
      type Client m (QueryString :> api) =
        H.Query -> Client m api

      clientWithRoute :: Proxy m
    -> Proxy (QueryString :> api)
    -> Request
    -> Client m (QueryString :> api)
    clientWithRoute Proxy m
    pm Proxy (QueryString :> api)
    Proxy Request
    req Query
    query =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)
                        (Query -> Request -> Request
    setQueryString Query
    query Request
    req)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (QueryString :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (QueryString :> api)
    -> Client mon' (QueryString :> api)
    hoistClientMonad Proxy m
    pm Proxy (QueryString :> api)
    _ forall x. mon x -> mon' x
    f Client mon (QueryString :> api)
    cl = \Query
    b ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (QueryString :> api)
    Query -> Client mon api
    cl Query
    b)

    instance (KnownSymbol sym, ToDeepQuery a, HasClient m api)
          => HasClient m (DeepQuery sym a :> api) where
      type Client m (DeepQuery sym a :> api) =
        a -> Client m api

      clientWithRoute :: Proxy m
    -> Proxy (DeepQuery sym a :> api)
    -> Request
    -> Client m (DeepQuery sym a :> api)
    clientWithRoute Proxy m
    pm Proxy (DeepQuery sym a :> api)
    Proxy Request
    req a
    deepObject =
        let params :: [([Text], Maybe Text)]
    params = a -> [([Text], Maybe Text)]
    forall a. ToDeepQuery a => a -> [([Text], Maybe Text)]
    toDeepQuery a
    deepObject
            withParams :: Request
    withParams = (Request -> ([Text], Maybe Text) -> Request)
    -> Request -> [([Text], Maybe Text)] -> Request
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: Type -> Type) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    List.foldl' Request -> ([Text], Maybe Text) -> Request
    addDeepParam Request
    req [([Text], Maybe Text)]
    params
            addDeepParam :: Request -> ([Text], Maybe Text) -> Request
    addDeepParam Request
    r' ([Text], Maybe Text)
    kv =
              let (Text
    k, Maybe Text
    textV) = Text -> ([Text], Maybe Text) -> (Text, Maybe Text)
    generateDeepParam Text
    paramname ([Text], Maybe Text)
    kv
               in Text -> Maybe Method -> Request -> Request
    appendToQueryString Text
    k (Text -> Method
    encodeUtf8 (Text -> Method) -> Maybe Text -> Maybe Method
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text
    textV) Request
    r'
            paramname :: Text
    paramname = String -> Text
    pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ Proxy sym -> String
    forall (n :: Symbol) (proxy :: Symbol -> Type).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy sym
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy sym)
         in Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)
                            Request
    withParams

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (DeepQuery sym a :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (DeepQuery sym a :> api)
    -> Client mon' (DeepQuery sym a :> api)
    hoistClientMonad Proxy m
    pm Proxy (DeepQuery sym a :> api)
    _ forall x. mon x -> mon' x
    f Client mon (DeepQuery sym a :> api)
    cl = \a
    b ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (DeepQuery sym a :> api)
    a -> Client mon api
    cl a
    b)

    -- | Pick a 'Method' and specify where the server you want to query is. You get
    -- back the full `Response`.
    instance RunClient m => HasClient m Raw where
      type Client m Raw
        = H.Method ->  m Response

      clientWithRoute :: Proxy m -> Proxy Raw -> Request -> Client m Raw
      clientWithRoute :: Proxy m -> Proxy Raw -> Request -> Client m Raw
    clientWithRoute Proxy m
    _pm Proxy Raw
    Proxy Request
    req Method
    httpMethod = do
        Request -> m Response
    forall (m :: Type -> Type). RunClient m => Request -> m Response
    runRequest Request
    req { requestMethod = httpMethod }

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy Raw
    -> (forall x. mon x -> mon' x)
    -> Client mon Raw
    -> Client mon' Raw
    hoistClientMonad Proxy m
    _ Proxy Raw
    _ forall x. mon x -> mon' x
    f Client mon Raw
    cl = \Method
    meth -> mon Response -> mon' Response
    forall x. mon x -> mon' x
    f (Client mon Raw
    Method -> mon Response
    cl Method
    meth)

    instance RunClient m => HasClient m RawM where
      type Client m RawM
        = H.Method ->  m Response

      clientWithRoute :: Proxy m -> Proxy RawM -> Request -> Client m RawM
      clientWithRoute :: Proxy m -> Proxy RawM -> Request -> Client m RawM
    clientWithRoute Proxy m
    _pm Proxy RawM
    Proxy Request
    req Method
    httpMethod = do
        Request -> m Response
    forall (m :: Type -> Type). RunClient m => Request -> m Response
    runRequest Request
    req { requestMethod = httpMethod }

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy RawM
    -> (forall x. mon x -> mon' x)
    -> Client mon RawM
    -> Client mon' RawM
    hoistClientMonad Proxy m
    _ Proxy RawM
    _ forall x. mon x -> mon' x
    f Client mon RawM
    cl = \Method
    meth -> mon Response -> mon' Response
    forall x. mon x -> mon' x
    f (Client mon RawM
    Method -> mon Response
    cl Method
    meth)

    -- | If you use a 'ReqBody' in one of your endpoints in your API,
    -- the corresponding querying function will automatically take
    -- an additional argument of the type specified by your 'ReqBody'.
    -- 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 endpoint
    instance (MimeRender ct a, HasClient m api)
          => HasClient m (ReqBody' mods (ct ': cts) a :> api) where

      type Client m (ReqBody' mods (ct ': cts) a :> api) =
        a -> Client m api

      clientWithRoute :: Proxy m
    -> Proxy (ReqBody' mods (ct : cts) a :> api)
    -> Request
    -> Client m (ReqBody' mods (ct : cts) a :> api)
    clientWithRoute Proxy m
    pm Proxy (ReqBody' mods (ct : cts) a :> api)
    Proxy Request
    req a
    body =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)
                        (let ctProxy :: Proxy ct
    ctProxy = Proxy ct
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy ct
                         in ByteString -> MediaType -> Request -> Request
    setRequestBodyLBS (Proxy ct -> a -> ByteString
    forall {k} (ctype :: k) a.
    MimeRender ctype a =>
    Proxy ctype -> a -> ByteString
    mimeRender Proxy ct
    ctProxy a
    body)
                                              -- We use first contentType from the Accept list
                                              (Proxy ct -> MediaType
    forall {k} (ctype :: k). Accept ctype => Proxy ctype -> MediaType
    contentType Proxy ct
    ctProxy)
                                              Request
    req
                        )

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (ReqBody' mods (ct : cts) a :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (ReqBody' mods (ct : cts) a :> api)
    -> Client mon' (ReqBody' mods (ct : cts) a :> api)
    hoistClientMonad Proxy m
    pm Proxy (ReqBody' mods (ct : cts) a :> api)
    _ forall x. mon x -> mon' x
    f Client mon (ReqBody' mods (ct : cts) a :> api)
    cl = \a
    a ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (ReqBody' mods (ct : cts) a :> api)
    a -> Client mon api
    cl a
    a)

    instance
        ( HasClient m api, MimeRender ctype chunk, FramingRender framing, ToSourceIO chunk a
        ) => HasClient m (StreamBody' mods framing ctype a :> api)
      where

        type Client m (StreamBody' mods framing ctype a :> api) = a -> Client m api

        hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (StreamBody' mods framing ctype a :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (StreamBody' mods framing ctype a :> api)
    -> Client mon' (StreamBody' mods framing ctype a :> api)
    hoistClientMonad Proxy m
    pm Proxy (StreamBody' mods framing ctype a :> api)
    _ forall x. mon x -> mon' x
    f Client mon (StreamBody' mods framing ctype a :> api)
    cl = \a
    a ->
          Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (StreamBody' mods framing ctype a :> api)
    a -> Client mon api
    cl a
    a)

        clientWithRoute :: Proxy m
    -> Proxy (StreamBody' mods framing ctype a :> api)
    -> Request
    -> Client m (StreamBody' mods framing ctype a :> api)
    clientWithRoute Proxy m
    pm Proxy (StreamBody' mods framing ctype a :> api)
    Proxy Request
    req a
    body
            = Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)
            (Request -> Client m api) -> Request -> Client m api
    forall a b. (a -> b) -> a -> b
    $ RequestBody -> MediaType -> Request -> Request
    setRequestBody (SourceIO ByteString -> RequestBody
    RequestBodySource SourceIO ByteString
    sourceIO) (Proxy ctype -> MediaType
    forall {k} (ctype :: k). Accept ctype => Proxy ctype -> MediaType
    contentType Proxy ctype
    ctypeP) Request
    req
          where
            ctypeP :: Proxy ctype
    ctypeP   = Proxy ctype
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy ctype
            framingP :: Proxy framing
    framingP = Proxy framing
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy framing

            sourceIO :: SourceIO ByteString
    sourceIO = Proxy framing
    -> (chunk -> ByteString) -> SourceT IO chunk -> SourceIO ByteString
    forall {k} (strategy :: k) (m :: Type -> Type) a.
    (FramingRender strategy, Monad m) =>
    Proxy strategy
    -> (a -> ByteString) -> SourceT m a -> SourceT m ByteString
    forall (m :: Type -> Type) a.
    Monad m =>
    Proxy framing
    -> (a -> ByteString) -> SourceT m a -> SourceT m ByteString
    framingRender
                Proxy framing
    framingP
                (Proxy ctype -> chunk -> ByteString
    forall {k} (ctype :: k) a.
    MimeRender ctype a =>
    Proxy ctype -> a -> ByteString
    mimeRender Proxy ctype
    ctypeP :: chunk -> BSL.ByteString)
                (a -> SourceT IO chunk
    forall chunk a. ToSourceIO chunk a => a -> SourceIO chunk
    toSourceIO a
    body)

    -- | Make the querying function append @path@ to the request path.
    instance (KnownSymbol path, HasClient m api) => HasClient m (path :> api) where
      type Client m (path :> api) = Client m api

      clientWithRoute :: Proxy m -> Proxy (path :> api) -> Request -> Client m (path :> api)
    clientWithRoute Proxy m
    pm Proxy (path :> api)
    Proxy Request
    req =
         Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)
                         (Builder -> Request -> Request
    appendToPath Builder
    p Request
    req)

        where p :: Builder
    p = Text -> Builder
    forall a. ToHttpApiData a => a -> Builder
    toEncodedUrlPiece (Text -> Builder) -> Text -> Builder
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ Proxy path -> String
    forall (n :: Symbol) (proxy :: Symbol -> Type).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy path
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy path)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (path :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (path :> api)
    -> Client mon' (path :> api)
    hoistClientMonad Proxy m
    pm Proxy (path :> api)
    _ forall x. mon x -> mon' x
    f Client mon (path :> api)
    cl = Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon api
    Client mon (path :> api)
    cl

    instance HasClient m api => HasClient m (Vault :> api) where
      type Client m (Vault :> api) = Client m api

      clientWithRoute :: Proxy m
    -> Proxy (Vault :> api) -> Request -> Client m (Vault :> api)
    clientWithRoute Proxy m
    pm Proxy (Vault :> api)
    Proxy Request
    req =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) Request
    req

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Vault :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Vault :> api)
    -> Client mon' (Vault :> api)
    hoistClientMonad Proxy m
    pm Proxy (Vault :> api)
    _ forall x. mon x -> mon' x
    f Client mon (Vault :> api)
    cl = Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon api
    Client mon (Vault :> api)
    cl

    instance HasClient m api => HasClient m (RemoteHost :> api) where
      type Client m (RemoteHost :> api) = Client m api

      clientWithRoute :: Proxy m
    -> Proxy (RemoteHost :> api)
    -> Request
    -> Client m (RemoteHost :> api)
    clientWithRoute Proxy m
    pm Proxy (RemoteHost :> api)
    Proxy Request
    req =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) Request
    req

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (RemoteHost :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (RemoteHost :> api)
    -> Client mon' (RemoteHost :> api)
    hoistClientMonad Proxy m
    pm Proxy (RemoteHost :> api)
    _ forall x. mon x -> mon' x
    f Client mon (RemoteHost :> api)
    cl = Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon api
    Client mon (RemoteHost :> api)
    cl

    instance HasClient m api => HasClient m (IsSecure :> api) where
      type Client m (IsSecure :> api) = Client m api

      clientWithRoute :: Proxy m
    -> Proxy (IsSecure :> api) -> Request -> Client m (IsSecure :> api)
    clientWithRoute Proxy m
    pm Proxy (IsSecure :> api)
    Proxy Request
    req =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) Request
    req

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (IsSecure :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (IsSecure :> api)
    -> Client mon' (IsSecure :> api)
    hoistClientMonad Proxy m
    pm Proxy (IsSecure :> api)
    _ forall x. mon x -> mon' x
    f Client mon (IsSecure :> api)
    cl = Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon api
    Client mon (IsSecure :> api)
    cl

    instance HasClient m subapi =>
      HasClient m (WithNamedContext name context subapi) where

      type Client m (WithNamedContext name context subapi) = Client m subapi
      clientWithRoute :: Proxy m
    -> Proxy (WithNamedContext name context subapi)
    -> Request
    -> Client m (WithNamedContext name context subapi)
    clientWithRoute Proxy m
    pm Proxy (WithNamedContext name context subapi)
    Proxy = Proxy m -> Proxy subapi -> Request -> Client m subapi
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy subapi
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy subapi)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (WithNamedContext name context subapi)
    -> (forall x. mon x -> mon' x)
    -> Client mon (WithNamedContext name context subapi)
    -> Client mon' (WithNamedContext name context subapi)
    hoistClientMonad Proxy m
    pm Proxy (WithNamedContext name context subapi)
    _ forall x. mon x -> mon' x
    f Client mon (WithNamedContext name context subapi)
    cl = Proxy m
    -> Proxy subapi
    -> (forall x. mon x -> mon' x)
    -> Client mon subapi
    -> Client mon' subapi
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy subapi
    -> (forall x. mon x -> mon' x)
    -> Client mon subapi
    -> Client mon' subapi
    hoistClientMonad Proxy m
    pm (Proxy subapi
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy subapi) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon subapi
    Client mon (WithNamedContext name context subapi)
    cl

    instance HasClient m subapi =>
      HasClient m (WithResource res :> subapi) where

      type Client m (WithResource res :> subapi) = Client m subapi
      clientWithRoute :: Proxy m
    -> Proxy (WithResource res :> subapi)
    -> Request
    -> Client m (WithResource res :> subapi)
    clientWithRoute Proxy m
    pm Proxy (WithResource res :> subapi)
    Proxy = Proxy m -> Proxy subapi -> Request -> Client m subapi
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy subapi
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy subapi)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (WithResource res :> subapi)
    -> (forall x. mon x -> mon' x)
    -> Client mon (WithResource res :> subapi)
    -> Client mon' (WithResource res :> subapi)
    hoistClientMonad Proxy m
    pm Proxy (WithResource res :> subapi)
    _ forall x. mon x -> mon' x
    f Client mon (WithResource res :> subapi)
    cl = Proxy m
    -> Proxy subapi
    -> (forall x. mon x -> mon' x)
    -> Client mon subapi
    -> Client mon' subapi
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy subapi
    -> (forall x. mon x -> mon' x)
    -> Client mon subapi
    -> Client mon' subapi
    hoistClientMonad Proxy m
    pm (Proxy subapi
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy subapi) mon x -> mon' x
    forall x. mon x -> mon' x
    f Client mon subapi
    Client mon (WithResource res :> subapi)
    cl

    instance ( HasClient m api
             ) => HasClient m (AuthProtect tag :> api) where
      type Client m (AuthProtect tag :> api)
        = AuthenticatedRequest (AuthProtect tag) -> Client m api

      clientWithRoute :: Proxy m
    -> Proxy (AuthProtect tag :> api)
    -> Request
    -> Client m (AuthProtect tag :> api)
    clientWithRoute Proxy m
    pm Proxy (AuthProtect tag :> api)
    Proxy Request
    req (AuthenticatedRequest (AuthClientData (AuthProtect tag)
    val,AuthClientData (AuthProtect tag) -> Request -> Request
    func)) =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) (AuthClientData (AuthProtect tag) -> Request -> Request
    func AuthClientData (AuthProtect tag)
    val Request
    req)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (AuthProtect tag :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (AuthProtect tag :> api)
    -> Client mon' (AuthProtect tag :> api)
    hoistClientMonad Proxy m
    pm Proxy (AuthProtect tag :> api)
    _ forall x. mon x -> mon' x
    f Client mon (AuthProtect tag :> api)
    cl = \AuthenticatedRequest (AuthProtect tag)
    authreq ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (AuthProtect tag :> api)
    AuthenticatedRequest (AuthProtect tag) -> Client mon api
    cl AuthenticatedRequest (AuthProtect tag)
    authreq)

    -- | Ignore @'Fragment'@ in client functions.
    -- See <https://ietf.org/rfc/rfc2616.html#section-15.1.3> for more details.
    --
    -- Example:
    --
    -- > type MyApi = "books" :> Fragment Text :> Get '[JSON] [Book]
    -- >
    -- > myApi :: Proxy MyApi
    -- > myApi = Proxy
    -- >
    -- > getBooks :: ClientM [Book]
    -- > getBooks = client myApi
    -- > -- then you can just use "getBooksBy" to query that endpoint.
    -- > -- 'getBooks' for all books.
    instance (AtMostOneFragment api, FragmentUnique (Fragment a :> api), HasClient m api
             ) => HasClient m (Fragment a :> api) where

      type Client m (Fragment a :> api) = Client m api

      clientWithRoute :: Proxy m
    -> Proxy (Fragment a :> api)
    -> Request
    -> Client m (Fragment a :> api)
    clientWithRoute Proxy m
    pm Proxy (Fragment a :> api)
    _ = Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (Fragment a :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (Fragment a :> api)
    -> Client mon' (Fragment a :> api)
    hoistClientMonad Proxy m
    pm Proxy (Fragment a :> api)
    _ = Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api)

    -- * Basic Authentication

    instance HasClient m api => HasClient m (BasicAuth realm usr :> api) where
      type Client m (BasicAuth realm usr :> api) = BasicAuthData -> Client m api

      clientWithRoute :: Proxy m
    -> Proxy (BasicAuth realm usr :> api)
    -> Request
    -> Client m (BasicAuth realm usr :> api)
    clientWithRoute Proxy m
    pm Proxy (BasicAuth realm usr :> api)
    Proxy Request
    req BasicAuthData
    val =
        Proxy m -> Proxy api -> Request -> Client m api
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) (BasicAuthData -> Request -> Request
    basicAuthReq BasicAuthData
    val Request
    req)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (BasicAuth realm usr :> api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (BasicAuth realm usr :> api)
    -> Client mon' (BasicAuth realm usr :> api)
    hoistClientMonad Proxy m
    pm Proxy (BasicAuth realm usr :> api)
    _ forall x. mon x -> mon' x
    f Client mon (BasicAuth realm usr :> api)
    cl = \BasicAuthData
    bauth ->
        Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad Proxy m
    pm (Proxy api
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy api) mon x -> mon' x
    forall x. mon x -> mon' x
    f (Client mon (BasicAuth realm usr :> api)
    BasicAuthData -> Client mon api
    cl BasicAuthData
    bauth)

    -- | A type that specifies that an API record contains a client implementation.
    data AsClientT (m :: Type -> Type)
    instance GenericMode (AsClientT m) where
        type AsClientT m :- api = Client m api

    type GClientConstraints api m =
      ( GenericServant api (AsClientT m)
      , Client m (ToServantApi api) ~ ToServant api (AsClientT m)
      )

    class GClient (api :: Type -> Type) m where
      gClientProof :: Dict (GClientConstraints api m)

    instance GClientConstraints api m => GClient api m where
      gClientProof :: Dict (GClientConstraints api m)
    gClientProof = Dict
      ((GenericMode (AsClientT m), Generic (api (AsClientT m)),
        GServantProduct (Rep (api (AsClientT m)))),
       GToServant (Rep (api (AsClientT m)))
       ~ GToServant (Rep (api (AsClientT m))))
    Dict (GClientConstraints api m)
    forall (a :: Constraint). a => Dict a
    Dict

    instance
      ( forall n. GClient api n
      , HasClient m (ToServantApi api)
      , RunClient m
      , ErrorIfNoGeneric api
      )
      => HasClient m (NamedRoutes api) where
      type Client m (NamedRoutes api) = api (AsClientT m)

      clientWithRoute :: Proxy m -> Proxy (NamedRoutes api) -> Request -> Client m (NamedRoutes api)
      clientWithRoute :: Proxy m
    -> Proxy (NamedRoutes api) -> Request -> Client m (NamedRoutes api)
    clientWithRoute Proxy m
    pm Proxy (NamedRoutes api)
    _ Request
    request =
        case forall (api :: Type -> Type) (m :: Type -> Type).
    GClient api m =>
    Dict (GClientConstraints api m)
    gClientProof @api @m of
          Dict (GClientConstraints api m)
    Dict -> GToServant (Rep (api (AsClientT m))) -> api (AsClientT m)
    forall {k} (routes :: k -> Type) (mode :: k).
    GenericServant routes mode =>
    ToServant routes mode -> routes mode
    fromServant (GToServant (Rep (api (AsClientT m))) -> api (AsClientT m))
    -> GToServant (Rep (api (AsClientT m))) -> api (AsClientT m)
    forall a b. (a -> b) -> a -> b
    $ Proxy m
    -> Proxy (ToServantApi api)
    -> Request
    -> Client m (ToServantApi api)
    forall (m :: Type -> Type) api.
    HasClient m api =>
    Proxy m -> Proxy api -> Request -> Client m api
    clientWithRoute  Proxy m
    pm (forall t. Proxy t
    forall {k} (t :: k). Proxy t
    Proxy @(ToServantApi api)) Request
    request

      hoistClientMonad
        :: forall ma mb.
           Proxy m
        -> Proxy (NamedRoutes api)
        -> (forall x. ma x -> mb x)
        -> Client ma (NamedRoutes api)
        -> Client mb (NamedRoutes api)
      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (NamedRoutes api)
    -> (forall x. mon x -> mon' x)
    -> Client mon (NamedRoutes api)
    -> Client mon' (NamedRoutes api)
    hoistClientMonad Proxy m
    _ Proxy (NamedRoutes api)
    _ forall x. ma x -> mb x
    nat Client ma (NamedRoutes api)
    clientA =
        case (forall (api :: Type -> Type) (m :: Type -> Type).
    GClient api m =>
    Dict (GClientConstraints api m)
    gClientProof @api @ma, forall (api :: Type -> Type) (m :: Type -> Type).
    GClient api m =>
    Dict (GClientConstraints api m)
    gClientProof @api @mb) of
          (Dict (GClientConstraints api ma)
    Dict, Dict (GClientConstraints api mb)
    Dict) ->
            forall {k} (routes :: k -> Type) (mode :: k).
    GenericServant routes mode =>
    ToServant routes mode -> routes mode
    forall (routes :: Type -> Type) mode.
    GenericServant routes mode =>
    ToServant routes mode -> routes mode
    fromServant @api @(AsClientT mb) (GToServant (Rep (api (AsClientT mb))) -> api (AsClientT mb))
    -> GToServant (Rep (api (AsClientT mb))) -> api (AsClientT mb)
    forall a b. (a -> b) -> a -> b
    $
            forall (m :: Type -> Type) api (mon :: Type -> Type)
           (mon' :: Type -> Type).
    HasClient m api =>
    Proxy m
    -> Proxy api
    -> (forall x. mon x -> mon' x)
    -> Client mon api
    -> Client mon' api
    hoistClientMonad @m @(ToServantApi api) @ma @mb Proxy m
    forall {k} (t :: k). Proxy t
    Proxy Proxy (ToServantApi api)
    forall {k} (t :: k). Proxy t
    Proxy ma x -> mb x
    forall x. ma x -> mb x
    nat (Client ma (ToServantApi api) -> Client mb (ToServantApi api))
    -> Client ma (ToServantApi api) -> Client mb (ToServantApi api)
    forall a b. (a -> b) -> a -> b
    $
            forall {k} (routes :: k -> Type) (mode :: k).
    GenericServant routes mode =>
    routes mode -> ToServant routes mode
    forall (routes :: Type -> Type) mode.
    GenericServant routes mode =>
    routes mode -> ToServant routes mode
    toServant @api @(AsClientT ma) api (AsClientT ma)
    Client ma (NamedRoutes api)
    clientA

    infixl 1 //
    infixl 2 /:

    -- | Helper to make code using records of clients more readable.
    --
    -- Can be mixed with (/:) for supplying arguments.
    --
    -- Example:
    --
    -- @
    -- type Api = NamedRoutes RootApi
    --
    -- data RootApi mode = RootApi
    --   { subApi :: mode :- NamedRoutes SubApi
    --   , …
    --   } deriving Generic
    --
    -- data SubApi mode = SubApi
    --   { endpoint :: mode :- Get '[JSON] Person
    --   , …
    --   } deriving Generic
    --
    -- api :: Proxy API
    -- api = Proxy
    --
    -- rootClient :: RootApi (AsClientT ClientM)
    -- rootClient = client api
    --
    -- endpointClient :: ClientM Person
    -- endpointClient = client \/\/ subApi \/\/ endpoint
    -- @
    (//) :: a -> (a -> b) -> b
    a
    x // :: forall a b. a -> (a -> b) -> b
    // a -> b
    f = a -> b
    f a
    x

    -- | Convenience function for supplying arguments to client functions when
    -- working with records of clients.
    --
    -- Intended to be used in conjunction with '(//)'.
    --
    -- Example:
    --
    -- @
    -- type Api = NamedRoutes RootApi
    --
    -- data RootApi mode = RootApi
    --   { subApi :: mode :- Capture "token" String :> NamedRoutes SubApi
    --   , hello :: mode :- Capture "name" String :> Get '[JSON] String
    --   , …
    --   } deriving Generic
    --
    -- data SubApi mode = SubApi
    --   { endpoint :: mode :- Get '[JSON] Person
    --   , …
    --   } deriving Generic
    --
    -- api :: Proxy API
    -- api = Proxy
    --
    -- rootClient :: RootApi (AsClientT ClientM)
    -- rootClient = client api
    --
    -- hello :: String -> ClientM String
    -- hello name = rootClient \/\/ hello \/: name
    --
    -- endpointClient :: ClientM Person
    -- endpointClient = client \/\/ subApi \/: "foobar123" \/\/ endpoint
    -- @
    (/:) :: (a -> b -> c) -> b -> a -> c
    /: :: forall a b c. (a -> b -> c) -> b -> a -> c
    (/:) = (a -> b -> c) -> b -> a -> c
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip

    instance
      ( ResponseListUnrender cs as,
        AllMime cs,
        ReflectMethod method,
        AsUnion as r,
        RunClient m
      ) =>
      HasClient m (MultiVerb method cs as r)
      where
      type Client m (MultiVerb method cs as r) = m r

      clientWithRoute :: Proxy m
    -> Proxy (MultiVerb method cs as r)
    -> Request
    -> Client m (MultiVerb method cs as r)
    clientWithRoute Proxy m
    _ Proxy (MultiVerb method cs as r)
    _ Request
    req = do
        response :: Response
    response@Response{responseBody :: forall a. ResponseF a -> a
    responseBody=ByteString
    body} <-
          Maybe [Status] -> Request -> m Response
    forall (m :: Type -> Type).
    RunClient m =>
    Maybe [Status] -> Request -> m Response
    runRequestAcceptStatus
            ([Status] -> Maybe [Status]
    forall a. a -> Maybe a
    Just (forall (cs :: [Type]) (as :: [Type]).
    ResponseListUnrender cs as =>
    [Status]
    forall {k} (cs :: k) (as :: [Type]).
    ResponseListUnrender cs as =>
    [Status]
    responseListStatuses @cs @as))
            Request
    req
              { requestMethod = method,
                requestAccept = Seq.fromList accept
              }

        MediaType
    c <- Response -> m MediaType
    forall (m :: Type -> Type). RunClient m => Response -> m MediaType
    getResponseContentType Response
    response
        Bool -> m () -> m ()
    forall (f :: Type -> Type). Applicative f => Bool -> f () -> f ()
    unless ((MediaType -> Bool) -> [MediaType] -> Bool
    forall (t :: Type -> Type) a.
    Foldable t =>
    (a -> Bool) -> t a -> Bool
    any (MediaType -> MediaType -> Bool
    forall a. Accept a => a -> a -> Bool
    M.matches MediaType
    c) [MediaType]
    accept) (m () -> m ()) -> m () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
          ClientError -> m ()
    forall a. ClientError -> m a
    forall (m :: Type -> Type) a. RunClient m => ClientError -> m a
    throwClientError (ClientError -> m ()) -> ClientError -> m ()
    forall a b. (a -> b) -> a -> b
    $ MediaType -> Response -> ClientError
    UnsupportedContentType MediaType
    c Response
    response

        -- NOTE: support streaming in the future
        let sresp :: SomeClientResponse
    sresp =
              if ByteString -> Bool
    BSL.null ByteString
    body
                then ResponseF () -> SomeClientResponse
    forall a. Typeable a => ResponseF a -> SomeClientResponse
    SomeClientResponse (ResponseF () -> SomeClientResponse)
    -> ResponseF () -> SomeClientResponse
    forall a b. (a -> b) -> a -> b
    $ Response
    response {Response.responseBody = ()}
                else Response -> SomeClientResponse
    forall a. Typeable a => ResponseF a -> SomeClientResponse
    SomeClientResponse Response
    response
        case forall (cs :: [Type]) (as :: [Type]).
    ResponseListUnrender cs as =>
    MediaType
    -> SomeClientResponse -> UnrenderResult (Union (ResponseTypes as))
    forall {k} (cs :: k) (as :: [Type]).
    ResponseListUnrender cs as =>
    MediaType
    -> SomeClientResponse -> UnrenderResult (Union (ResponseTypes as))
    responseListUnrender @cs @as MediaType
    c SomeClientResponse
    sresp of
          UnrenderResult (Union (ResponseTypes as))
    StatusMismatch -> ClientError -> m r
    forall a. ClientError -> m a
    forall (m :: Type -> Type) a. RunClient m => ClientError -> m a
    throwClientError (Text -> Response -> ClientError
    DecodeFailure Text
    "Status mismatch" Response
    response)
          UnrenderError String
    e -> ClientError -> m r
    forall a. ClientError -> m a
    forall (m :: Type -> Type) a. RunClient m => ClientError -> m a
    throwClientError (Text -> Response -> ClientError
    DecodeFailure (String -> Text
    Text.pack String
    e) Response
    response)
          UnrenderSuccess Union (ResponseTypes as)
    x -> r -> m r
    forall a. a -> m a
    forall (f :: Type -> Type) a. Applicative f => a -> f a
    pure (forall (as :: [Type]) r.
    AsUnion as r =>
    Union (ResponseTypes as) -> r
    fromUnion @as Union (ResponseTypes as)
    x)
        where
          accept :: [MediaType]
    accept = Proxy cs -> [MediaType]
    forall (list :: [Type]). AllMime list => Proxy list -> [MediaType]
    allMime (forall (t :: [Type]). Proxy t
    forall {k} (t :: k). Proxy t
    Proxy @cs)
          method :: Method
    method = Proxy method -> Method
    forall {k} (a :: k). ReflectMethod a => Proxy a -> Method
    reflectMethod (forall {k} (t :: k). Proxy t
    forall (t :: StdMethod). Proxy t
    Proxy @method)

      hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (MultiVerb method cs as r)
    -> (forall x. mon x -> mon' x)
    -> Client mon (MultiVerb method cs as r)
    -> Client mon' (MultiVerb method cs as r)
    hoistClientMonad Proxy m
    _ Proxy (MultiVerb method cs as r)
    _ forall x. mon x -> mon' x
    f = mon r -> mon' r
    Client mon (MultiVerb method cs as r)
    -> Client mon' (MultiVerb method cs as r)
    forall x. mon x -> mon' x
    f

    getResponseContentType :: (RunClient m) => Response -> m M.MediaType
    getResponseContentType :: forall (m :: Type -> Type). RunClient m => Response -> m MediaType
    getResponseContentType Response
    response =
      case HeaderName -> [Header] -> Maybe Method
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup HeaderName
    "Content-Type" (Seq Header -> [Header]
    forall a. Seq a -> [a]
    forall (t :: Type -> Type) a. Foldable t => t a -> [a]
    toList (Response -> Seq Header
    forall a. ResponseF a -> Seq Header
    responseHeaders Response
    response)) of
        Maybe Method
    Nothing -> MediaType -> m MediaType
    forall a. a -> m a
    forall (f :: Type -> Type) a. Applicative f => a -> f a
    pure (MediaType -> m MediaType) -> MediaType -> m MediaType
    forall a b. (a -> b) -> a -> b
    $ Method
    "application" Method -> Method -> MediaType
    M.// Method
    "octet-stream"
        Just Method
    t -> case Method -> Maybe MediaType
    forall a. Accept a => Method -> Maybe a
    M.parseAccept Method
    t of
          Maybe MediaType
    Nothing -> ClientError -> m MediaType
    forall a. ClientError -> m a
    forall (m :: Type -> Type) a. RunClient m => ClientError -> m a
    throwClientError (ClientError -> m MediaType) -> ClientError -> m MediaType
    forall a b. (a -> b) -> a -> b
    $ Response -> ClientError
    InvalidContentTypeHeader Response
    response
          Just MediaType
    t' -> MediaType -> m MediaType
    forall a. a -> m a
    forall (f :: Type -> Type) a. Applicative f => a -> f a
    pure MediaType
    t'

    {- Note [Non-Empty Content Types]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Rather than have

       instance (..., cts' ~ (ct ': cts)) => ... cts' ...

    It may seem to make more sense to have:

       instance (...) => ... (ct ': cts) ...

    But this means that if another instance exists that does *not* require
    non-empty lists, but is otherwise more specific, no instance will be overall
    more specific. This in turn generally means adding yet another instance (one
    for empty and one for non-empty lists).
    -}

    -------------------------------------------------------------------------------
    -- helpers
    -------------------------------------------------------------------------------

    checkContentTypeHeader :: RunClient m => Response -> m MediaType
    checkContentTypeHeader :: forall (m :: Type -> Type). RunClient m => Response -> m MediaType
    checkContentTypeHeader Response
    response =
      case HeaderName -> [Header] -> Maybe Method
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup HeaderName
    "Content-Type" ([Header] -> Maybe Method) -> [Header] -> Maybe Method
    forall a b. (a -> b) -> a -> b
    $ Seq Header -> [Header]
    forall a. Seq a -> [a]
    forall (t :: Type -> Type) a. Foldable t => t a -> [a]
    toList (Seq Header -> [Header]) -> Seq Header -> [Header]
    forall a b. (a -> b) -> a -> b
    $ Response -> Seq Header
    forall a. ResponseF a -> Seq Header
    responseHeaders Response
    response of
        Maybe Method
    Nothing -> MediaType -> m MediaType
    forall a. a -> m a
    forall (m :: Type -> Type) a. Monad m => a -> m a
    return (MediaType -> m MediaType) -> MediaType -> m MediaType
    forall a b. (a -> b) -> a -> b
    $ Method
    "application" Method -> Method -> MediaType
    Media.// Method
    "octet-stream"
        Just Method
    t -> case Method -> Maybe MediaType
    forall a. Accept a => Method -> Maybe a
    parseAccept Method
    t of
          Maybe MediaType
    Nothing -> ClientError -> m MediaType
    forall a. ClientError -> m a
    forall (m :: Type -> Type) a. RunClient m => ClientError -> m a
    throwClientError (ClientError -> m MediaType) -> ClientError -> m MediaType
    forall a b. (a -> b) -> a -> b
    $ Response -> ClientError
    InvalidContentTypeHeader Response
    response
          Just MediaType
    t' -> MediaType -> m MediaType
    forall a. a -> m a
    forall (m :: Type -> Type) a. Monad m => a -> m a
    return MediaType
    t'

    decodedAs :: forall ct a m. (MimeUnrender ct a, RunClient m)
      => Response -> Proxy ct -> m a
    decodedAs :: forall {k} (ct :: k) a (m :: Type -> Type).
    (MimeUnrender ct a, RunClient m) =>
    Response -> Proxy ct -> m a
    decodedAs response :: Response
    response@Response{responseBody :: forall a. ResponseF a -> a
    responseBody=ByteString
    body} Proxy ct
    ct = do
      MediaType
    responseContentType <- Response -> m MediaType
    forall (m :: Type -> Type). RunClient m => Response -> m MediaType
    checkContentTypeHeader Response
    response
      Bool -> m () -> m ()
    forall (f :: Type -> Type). Applicative f => Bool -> f () -> f ()
    unless ((MediaType -> Bool) -> [MediaType] -> Bool
    forall (t :: Type -> Type) a.
    Foldable t =>
    (a -> Bool) -> t a -> Bool
    any (MediaType -> MediaType -> Bool
    forall a. Accept a => a -> a -> Bool
    matches MediaType
    responseContentType) [MediaType]
    accept) (m () -> m ()) -> m () -> m ()
    forall a b. (a -> b) -> a -> b
    $
        ClientError -> m ()
    forall a. ClientError -> m a
    forall (m :: Type -> Type) a. RunClient m => ClientError -> m a
    throwClientError (ClientError -> m ()) -> ClientError -> m ()
    forall a b. (a -> b) -> a -> b
    $ MediaType -> Response -> ClientError
    UnsupportedContentType MediaType
    responseContentType Response
    response
      case Proxy ct -> ByteString -> Either String a
    forall {k} (ctype :: k) a.
    MimeUnrender ctype a =>
    Proxy ctype -> ByteString -> Either String a
    mimeUnrender Proxy ct
    ct ByteString
    body of
        Left String
    err -> ClientError -> m a
    forall a. ClientError -> m a
    forall (m :: Type -> Type) a. RunClient m => ClientError -> m a
    throwClientError (ClientError -> m a) -> ClientError -> m a
    forall a b. (a -> b) -> a -> b
    $ Text -> Response -> ClientError
    DecodeFailure (String -> Text
    T.pack String
    err) Response
    response
        Right a
    val -> a -> m a
    forall a. a -> m a
    forall (m :: Type -> Type) a. Monad m => a -> m a
    return a
    val
      where
        accept :: [MediaType]
    accept = NonEmpty MediaType -> [MediaType]
    forall a. NonEmpty a -> [a]
    forall (t :: Type -> Type) a. Foldable t => t a -> [a]
    toList (NonEmpty MediaType -> [MediaType])
    -> NonEmpty MediaType -> [MediaType]
    forall a b. (a -> b) -> a -> b
    $ Proxy ct -> NonEmpty MediaType
    forall {k} (ctype :: k).
    Accept ctype =>
    Proxy ctype -> NonEmpty MediaType
    contentTypes Proxy ct
    ct

    -------------------------------------------------------------------------------
    -- Custom type errors
    -------------------------------------------------------------------------------

    -- Erroring instance for HasClient' when a combinator is not fully applied
    instance (RunClient m, TypeError (PartialApplication HasClient arr)) => HasClient m ((arr :: a -> b) :> sub)
      where
        type Client m (arr :> sub) = TypeError (PartialApplication HasClient arr)
        clientWithRoute :: Proxy m -> Proxy (arr :> sub) -> Request -> Client m (arr :> sub)
    clientWithRoute Proxy m
    _ Proxy (arr :> sub)
    _ Request
    _ = String -> (TypeError ...)
    forall a. HasCallStack => String -> a
    error String
    "unreachable"
        hoistClientMonad :: forall (mon :: Type -> Type) (mon' :: Type -> Type).
    Proxy m
    -> Proxy (arr :> sub)
    -> (forall x. mon x -> mon' x)
    -> Client mon (arr :> sub)
    -> Client mon' (arr :> sub)
    hoistClientMonad Proxy m
    _ Proxy (arr :> sub)
    _ forall x. mon x -> mon' x
    _ Client mon (arr :> sub)
    _ = String -> (TypeError ...)
    forall a. HasCallStack => String -> a
    error String
    "unreachable"

    -- Erroring instances for 'HasClient' for unknown API combinators
    instance {-# OVERLAPPABLE #-} (RunClient m, TypeError (NoInstanceForSub (HasClient m) ty)) => HasClient m (ty :> sub)

    instance {-# OVERLAPPABLE #-} (RunClient m, TypeError (NoInstanceFor (HasClient m api))) => HasClient m api