module Network.IPFS.Client
  ( API
  , add
  , cat
  , stat
  , pin
  , unpin
  ) where

import qualified RIO.ByteString.Lazy as Lazy
import           Servant
import           Servant.Client

import Network.IPFS.Internal.Orphanage.ByteString.Lazy ()
import Network.IPFS.Prelude                            hiding (object)

import           Network.IPFS.CID.Types
import qualified Network.IPFS.File.Types as File
import           Network.IPFS.Stat.Types

import qualified Network.IPFS.Client.Add  as Add
import qualified Network.IPFS.Client.Cat  as Cat
import qualified Network.IPFS.Client.Pin  as Pin
import qualified Network.IPFS.Client.Stat as Stat

type API
  = "api"
  :> "v0"
  :> V0API

type V0API = "add"    :> Add.API
        :<|> "cat"    :> Cat.API
        :<|> "object" :> Stat.API
        :<|> "pin"    :> Pin.API

add   :: Lazy.ByteString -> ClientM CID
cat   :: Text            -> ClientM File.Serialized
stat  :: Text            -> ClientM Stat
pin   :: Text            -> ClientM Pin.Response
unpin :: Text -> Bool    -> ClientM Pin.Response

ByteString -> ClientM CID
add :<|> Text -> ClientM Serialized
cat
    :<|> Text -> ClientM Stat
stat
    :<|> Text -> ClientM Response
pin
    :<|> Text -> Bool -> ClientM Response
unpin
    = Proxy API
-> (ByteString -> ClientM CID)
   :<|> ((Text -> ClientM Serialized)
         :<|> ((Text -> ClientM Stat)
               :<|> ((Text -> ClientM Response)
                     :<|> (Text -> Bool -> ClientM Response))))
forall api.
HasClient ClientM api =>
Proxy api -> Client ClientM api
client (Proxy API
 -> (ByteString -> ClientM CID)
    :<|> ((Text -> ClientM Serialized)
          :<|> ((Text -> ClientM Stat)
                :<|> ((Text -> ClientM Response)
                      :<|> (Text -> Bool -> ClientM Response)))))
-> Proxy API
-> (ByteString -> ClientM CID)
   :<|> ((Text -> ClientM Serialized)
         :<|> ((Text -> ClientM Stat)
               :<|> ((Text -> ClientM Response)
                     :<|> (Text -> Bool -> ClientM Response))))
forall a b. (a -> b) -> a -> b
<| Proxy API
forall k (t :: k). Proxy t
Proxy @API