-- | Client Types
{-# LANGUAGE CPP #-}

module Blockfrost.Client.Types
  ( BlockfrostClient
  , BlockfrostError (..)
  , ClientConfig
  , runBlockfrost
  , apiClient
  , api0Client
  , commonClient
  , cardanoClient
  , ipfsClient
  , nutLinkClient
  , Project (..)
  , Paged (..)
  , SortOrder (..)
  , go
  , AsClientT
  , fromServant
  , tryError
  , def
  ) where

import Control.Monad.Except
import Control.Monad.Reader
import Data.Default

import Servant.API.Generic
import Servant.Client
import Servant.Client.Generic

import Blockfrost.API
import Blockfrost.Client.Core

type ClientConfig = (ClientEnv, Project)
type BlockfrostClient =
  ExceptT BlockfrostError
    (ReaderT ClientConfig IO)

apiClient :: BlockfrostAPI (AsClientT BlockfrostClient)
apiClient :: BlockfrostAPI (AsClientT BlockfrostClient)
apiClient = (forall x. ClientM x -> BlockfrostClient x)
-> BlockfrostAPI (AsClientT BlockfrostClient)
forall (routes :: * -> *) (m :: * -> *) (n :: * -> *).
(HasClient m (ToServantApi routes),
 GenericServant routes (AsClientT n),
 Client n (ToServantApi routes) ~ ToServant routes (AsClientT n)) =>
(forall x. m x -> n x) -> routes (AsClientT n)
genericClientHoist forall x. ClientM x -> BlockfrostClient x
nt
  where nt :: ClientM a -> BlockfrostClient a
        nt :: ClientM a -> BlockfrostClient a
nt ClientM a
act = do
          (ClientEnv
env, Project
_proj) <- ExceptT
  BlockfrostError
  (ReaderT (ClientEnv, Project) IO)
  (ClientEnv, Project)
forall r (m :: * -> *). MonadReader r m => m r
ask
          IO (Either ClientError a)
-> ExceptT
     BlockfrostError
     (ReaderT (ClientEnv, Project) IO)
     (Either ClientError a)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ClientM a -> ClientEnv -> IO (Either ClientError a)
forall a. ClientM a -> ClientEnv -> IO (Either ClientError a)
runClientM ClientM a
act ClientEnv
env)
            ExceptT
  BlockfrostError
  (ReaderT (ClientEnv, Project) IO)
  (Either ClientError a)
-> (Either ClientError a -> BlockfrostClient a)
-> BlockfrostClient a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ClientError -> BlockfrostClient a)
-> (a -> BlockfrostClient a)
-> Either ClientError a
-> BlockfrostClient a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (BlockfrostError -> BlockfrostClient a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (BlockfrostError -> BlockfrostClient a)
-> (ClientError -> BlockfrostError)
-> ClientError
-> BlockfrostClient a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClientError -> BlockfrostError
fromServantClientError) a -> BlockfrostClient a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

api0Client :: Project -> BlockfrostV0API (AsClientT BlockfrostClient)
api0Client :: Project -> BlockfrostV0API (AsClientT BlockfrostClient)
api0Client = ((((ExceptT
      BlockfrostError (ReaderT (ClientEnv, Project) IO) URLVersion
    :<|> ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) Healthy)
   :<|> (ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) ServerTime
         :<|> (ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [Metric]
               :<|> ExceptT
                      BlockfrostError
                      (ReaderT (ClientEnv, Project) IO)
                      [(Text, Metric)])))
  :<|> ((((((Address
             -> ExceptT
                  BlockfrostError (ReaderT (ClientEnv, Project) IO) AccountInfo)
            :<|> ((Address
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountReward])
                  :<|> (Address
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError
                             (ReaderT (ClientEnv, Project) IO)
                             [AccountHistory])))
           :<|> (((Address
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError
                        (ReaderT (ClientEnv, Project) IO)
                        [AccountDelegation])
                  :<|> (Address
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError
                             (ReaderT (ClientEnv, Project) IO)
                             [AccountRegistration]))
                 :<|> ((Address
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError
                             (ReaderT (ClientEnv, Project) IO)
                             [AccountWithdrawal])
                       :<|> (Address
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountMir]))))
          :<|> (((Address
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressInfo)
                 :<|> (Address
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressDetails))
                :<|> ((Address
                       -> Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [AddressUTXO])
                      :<|> (Address
                            -> Paged
                            -> SortOrder
                            -> Maybe BlockIndex
                            -> Maybe BlockIndex
                            -> ExceptT
                                 BlockfrostError
                                 (ReaderT (ClientEnv, Project) IO)
                                 [AddressTransaction]))))
         :<|> ((((Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo])
                 :<|> ((AssetId
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) AssetDetails)
                       :<|> (AssetId
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  [AssetHistory])))
                :<|> ((AssetId
                       -> Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError
                            (ReaderT (ClientEnv, Project) IO)
                            [AssetTransaction])
                      :<|> ((AssetId
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetAddress])
                            :<|> (PolicyId
                                  -> Paged
                                  -> SortOrder
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [AssetInfo]))))
               :<|> ((((ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) Block
                        :<|> (Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxHash]))
                       :<|> ((Either Integer BlockHash
                              -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                             :<|> (Slot
                                   -> ExceptT
                                        BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)))
                      :<|> (((Epoch
                              -> Slot
                              -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                             :<|> (Either Integer BlockHash
                                   -> Paged
                                   -> ExceptT
                                        BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block]))
                            :<|> ((Either Integer BlockHash
                                   -> Paged
                                   -> ExceptT
                                        BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block])
                                  :<|> (Either Integer BlockHash
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [TxHash]))))
                     :<|> (((ExceptT
                               BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo
                             :<|> ExceptT
                                    BlockfrostError
                                    (ReaderT (ClientEnv, Project) IO)
                                    ProtocolParams)
                            :<|> ((Epoch
                                   -> ExceptT
                                        BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo)
                                  :<|> ((Epoch
                                         -> Paged
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [EpochInfo])
                                        :<|> (Epoch
                                              -> Paged
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [EpochInfo]))))
                           :<|> (((Epoch
                                   -> Paged
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [StakeDistribution])
                                  :<|> (Epoch
                                        -> PoolId
                                        -> Paged
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [StakeDistribution]))
                                 :<|> ((Epoch
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [BlockHash])
                                       :<|> ((Epoch
                                              -> PoolId
                                              -> Paged
                                              -> SortOrder
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [BlockHash])
                                             :<|> (Epoch
                                                   -> ExceptT
                                                        BlockfrostError
                                                        (ReaderT (ClientEnv, Project) IO)
                                                        ProtocolParams))))))))
        :<|> ((ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) Genesis
               :<|> (((Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMeta])
                      :<|> ((Text
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaJSON])
                            :<|> (Text
                                  -> Paged
                                  -> SortOrder
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [TxMetaCBOR])))
                     :<|> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) Network))
              :<|> (((((Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolId])
                       :<|> (Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch]))
                      :<|> ((Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch])
                            :<|> ((PoolId
                                   -> ExceptT
                                        BlockfrostError (ReaderT (ClientEnv, Project) IO) PoolInfo)
                                  :<|> (PoolId
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [PoolHistory]))))
                     :<|> (((PoolId
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  (Maybe PoolMetadata))
                            :<|> (PoolId
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [PoolRelay]))
                           :<|> ((PoolId
                                  -> Paged
                                  -> SortOrder
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [PoolDelegator])
                                 :<|> ((PoolId
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [BlockHash])
                                       :<|> (PoolId
                                             -> Paged
                                             -> SortOrder
                                             -> ExceptT
                                                  BlockfrostError
                                                  (ReaderT (ClientEnv, Project) IO)
                                                  [PoolUpdate])))))
                    :<|> (((((TxHash
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                             :<|> (TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        TransactionUtxos))
                            :<|> ((TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TransactionStake])
                                  :<|> ((TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionDelegation])
                                        :<|> (TxHash
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [TransactionWithdrawal]))))
                           :<|> (((TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TransactionMir])
                                  :<|> (TxHash
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [TransactionPoolUpdate]))
                                 :<|> ((TxHash
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [TransactionPoolRetiring])
                                       :<|> ((TxHash
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [TransactionMetaJSON])
                                             :<|> (TxHash
                                                   -> ExceptT
                                                        BlockfrostError
                                                        (ReaderT (ClientEnv, Project) IO)
                                                        [TransactionMetaCBOR])))))
                          :<|> (CBORString
                                -> ExceptT
                                     BlockfrostError (ReaderT (ClientEnv, Project) IO) TxHash))))))
 :<|> (((((ByteString, Form)
          -> ExceptT
               BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSAdd)
         :<|> ((Text
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSData)
               :<|> (Text
                     -> ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
        :<|> ((Paged
               -> SortOrder
               -> ExceptT
                    BlockfrostError (ReaderT (ClientEnv, Project) IO) [IPFSPin])
              :<|> ((Text
                     -> ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPin)
                    :<|> (Text
                          -> ExceptT
                               BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange))))
       :<|> (((Address
               -> ExceptT
                    BlockfrostError (ReaderT (ClientEnv, Project) IO) NutlinkAddress)
              :<|> (Address
                    -> Paged
                    -> SortOrder
                    -> ExceptT
                         BlockfrostError
                         (ReaderT (ClientEnv, Project) IO)
                         [NutlinkAddressTicker]))
             :<|> ((Address
                    -> Text
                    -> Paged
                    -> SortOrder
                    -> ExceptT
                         BlockfrostError (ReaderT (ClientEnv, Project) IO) [NutlinkTicker])
                   :<|> (Text
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError
                              (ReaderT (ClientEnv, Project) IO)
                              [(Address, NutlinkTicker)])))))
-> BlockfrostV0API (AsClientT BlockfrostClient)
forall (routes :: * -> *) mode.
GenericServant routes mode =>
ToServant routes mode -> routes mode
fromServant (((((ExceptT
       BlockfrostError (ReaderT (ClientEnv, Project) IO) URLVersion
     :<|> ExceptT
            BlockfrostError (ReaderT (ClientEnv, Project) IO) Healthy)
    :<|> (ExceptT
            BlockfrostError (ReaderT (ClientEnv, Project) IO) ServerTime
          :<|> (ExceptT
                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [Metric]
                :<|> ExceptT
                       BlockfrostError
                       (ReaderT (ClientEnv, Project) IO)
                       [(Text, Metric)])))
   :<|> ((((((Address
              -> ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) AccountInfo)
             :<|> ((Address
                    -> Paged
                    -> SortOrder
                    -> ExceptT
                         BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountReward])
                   :<|> (Address
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError
                              (ReaderT (ClientEnv, Project) IO)
                              [AccountHistory])))
            :<|> (((Address
                    -> Paged
                    -> SortOrder
                    -> ExceptT
                         BlockfrostError
                         (ReaderT (ClientEnv, Project) IO)
                         [AccountDelegation])
                   :<|> (Address
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError
                              (ReaderT (ClientEnv, Project) IO)
                              [AccountRegistration]))
                  :<|> ((Address
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError
                              (ReaderT (ClientEnv, Project) IO)
                              [AccountWithdrawal])
                        :<|> (Address
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [AccountMir]))))
           :<|> (((Address
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressInfo)
                  :<|> (Address
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressDetails))
                 :<|> ((Address
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [AddressUTXO])
                       :<|> (Address
                             -> Paged
                             -> SortOrder
                             -> Maybe BlockIndex
                             -> Maybe BlockIndex
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  [AddressTransaction]))))
          :<|> ((((Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo])
                  :<|> ((AssetId
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) AssetDetails)
                        :<|> (AssetId
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [AssetHistory])))
                 :<|> ((AssetId
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError
                             (ReaderT (ClientEnv, Project) IO)
                             [AssetTransaction])
                       :<|> ((AssetId
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetAddress])
                             :<|> (PolicyId
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [AssetInfo]))))
                :<|> ((((ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) Block
                         :<|> (Paged
                               -> SortOrder
                               -> ExceptT
                                    BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxHash]))
                        :<|> ((Either Integer BlockHash
                               -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                              :<|> (Slot
                                    -> ExceptT
                                         BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)))
                       :<|> (((Epoch
                               -> Slot
                               -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                              :<|> (Either Integer BlockHash
                                    -> Paged
                                    -> ExceptT
                                         BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block]))
                             :<|> ((Either Integer BlockHash
                                    -> Paged
                                    -> ExceptT
                                         BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block])
                                   :<|> (Either Integer BlockHash
                                         -> Paged
                                         -> SortOrder
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TxHash]))))
                      :<|> (((ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo
                              :<|> ExceptT
                                     BlockfrostError
                                     (ReaderT (ClientEnv, Project) IO)
                                     ProtocolParams)
                             :<|> ((Epoch
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         EpochInfo)
                                   :<|> ((Epoch
                                          -> Paged
                                          -> ExceptT
                                               BlockfrostError
                                               (ReaderT (ClientEnv, Project) IO)
                                               [EpochInfo])
                                         :<|> (Epoch
                                               -> Paged
                                               -> ExceptT
                                                    BlockfrostError
                                                    (ReaderT (ClientEnv, Project) IO)
                                                    [EpochInfo]))))
                            :<|> (((Epoch
                                    -> Paged
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [StakeDistribution])
                                   :<|> (Epoch
                                         -> PoolId
                                         -> Paged
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [StakeDistribution]))
                                  :<|> ((Epoch
                                         -> Paged
                                         -> SortOrder
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [BlockHash])
                                        :<|> ((Epoch
                                               -> PoolId
                                               -> Paged
                                               -> SortOrder
                                               -> ExceptT
                                                    BlockfrostError
                                                    (ReaderT (ClientEnv, Project) IO)
                                                    [BlockHash])
                                              :<|> (Epoch
                                                    -> ExceptT
                                                         BlockfrostError
                                                         (ReaderT (ClientEnv, Project) IO)
                                                         ProtocolParams))))))))
         :<|> ((ExceptT
                  BlockfrostError (ReaderT (ClientEnv, Project) IO) Genesis
                :<|> (((Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMeta])
                       :<|> ((Text
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaJSON])
                             :<|> (Text
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TxMetaCBOR])))
                      :<|> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) Network))
               :<|> (((((Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolId])
                        :<|> (Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch]))
                       :<|> ((Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch])
                             :<|> ((PoolId
                                    -> ExceptT
                                         BlockfrostError (ReaderT (ClientEnv, Project) IO) PoolInfo)
                                   :<|> (PoolId
                                         -> Paged
                                         -> SortOrder
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [PoolHistory]))))
                      :<|> (((PoolId
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   (Maybe PoolMetadata))
                             :<|> (PoolId
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [PoolRelay]))
                            :<|> ((PoolId
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [PoolDelegator])
                                  :<|> ((PoolId
                                         -> Paged
                                         -> SortOrder
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [BlockHash])
                                        :<|> (PoolId
                                              -> Paged
                                              -> SortOrder
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [PoolUpdate])))))
                     :<|> (((((TxHash
                               -> ExceptT
                                    BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                              :<|> (TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         TransactionUtxos))
                             :<|> ((TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [TransactionStake])
                                   :<|> ((TxHash
                                          -> ExceptT
                                               BlockfrostError
                                               (ReaderT (ClientEnv, Project) IO)
                                               [TransactionDelegation])
                                         :<|> (TxHash
                                               -> ExceptT
                                                    BlockfrostError
                                                    (ReaderT (ClientEnv, Project) IO)
                                                    [TransactionWithdrawal]))))
                            :<|> (((TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [TransactionMir])
                                   :<|> (TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionPoolUpdate]))
                                  :<|> ((TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionPoolRetiring])
                                        :<|> ((TxHash
                                               -> ExceptT
                                                    BlockfrostError
                                                    (ReaderT (ClientEnv, Project) IO)
                                                    [TransactionMetaJSON])
                                              :<|> (TxHash
                                                    -> ExceptT
                                                         BlockfrostError
                                                         (ReaderT (ClientEnv, Project) IO)
                                                         [TransactionMetaCBOR])))))
                           :<|> (CBORString
                                 -> ExceptT
                                      BlockfrostError (ReaderT (ClientEnv, Project) IO) TxHash))))))
  :<|> (((((ByteString, Form)
           -> ExceptT
                BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSAdd)
          :<|> ((Text
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSData)
                :<|> (Text
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
         :<|> ((Paged
                -> SortOrder
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) [IPFSPin])
               :<|> ((Text
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPin)
                     :<|> (Text
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange))))
        :<|> (((Address
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) NutlinkAddress)
               :<|> (Address
                     -> Paged
                     -> SortOrder
                     -> ExceptT
                          BlockfrostError
                          (ReaderT (ClientEnv, Project) IO)
                          [NutlinkAddressTicker]))
              :<|> ((Address
                     -> Text
                     -> Paged
                     -> SortOrder
                     -> ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) [NutlinkTicker])
                    :<|> (Text
                          -> Paged
                          -> SortOrder
                          -> ExceptT
                               BlockfrostError
                               (ReaderT (ClientEnv, Project) IO)
                               [(Address, NutlinkTicker)])))))
 -> BlockfrostV0API (AsClientT BlockfrostClient))
-> (Project
    -> (((ExceptT
            BlockfrostError (ReaderT (ClientEnv, Project) IO) URLVersion
          :<|> ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) Healthy)
         :<|> (ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) ServerTime
               :<|> (ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [Metric]
                     :<|> ExceptT
                            BlockfrostError
                            (ReaderT (ClientEnv, Project) IO)
                            [(Text, Metric)])))
        :<|> ((((((Address
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) AccountInfo)
                  :<|> ((Address
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountReward])
                        :<|> (Address
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [AccountHistory])))
                 :<|> (((Address
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError
                              (ReaderT (ClientEnv, Project) IO)
                              [AccountDelegation])
                        :<|> (Address
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [AccountRegistration]))
                       :<|> ((Address
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [AccountWithdrawal])
                             :<|> (Address
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [AccountMir]))))
                :<|> (((Address
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressInfo)
                       :<|> (Address
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressDetails))
                      :<|> ((Address
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [AddressUTXO])
                            :<|> (Address
                                  -> Paged
                                  -> SortOrder
                                  -> Maybe BlockIndex
                                  -> Maybe BlockIndex
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [AddressTransaction]))))
               :<|> ((((Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo])
                       :<|> ((AssetId
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) AssetDetails)
                             :<|> (AssetId
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [AssetHistory])))
                      :<|> ((AssetId
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  [AssetTransaction])
                            :<|> ((AssetId
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [AssetAddress])
                                  :<|> (PolicyId
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [AssetInfo]))))
                     :<|> ((((ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) Block
                              :<|> (Paged
                                    -> SortOrder
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [TxHash]))
                             :<|> ((Either Integer BlockHash
                                    -> ExceptT
                                         BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                                   :<|> (Slot
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              Block)))
                            :<|> (((Epoch
                                    -> Slot
                                    -> ExceptT
                                         BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                                   :<|> (Either Integer BlockHash
                                         -> Paged
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [Block]))
                                  :<|> ((Either Integer BlockHash
                                         -> Paged
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [Block])
                                        :<|> (Either Integer BlockHash
                                              -> Paged
                                              -> SortOrder
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [TxHash]))))
                           :<|> (((ExceptT
                                     BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo
                                   :<|> ExceptT
                                          BlockfrostError
                                          (ReaderT (ClientEnv, Project) IO)
                                          ProtocolParams)
                                  :<|> ((Epoch
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              EpochInfo)
                                        :<|> ((Epoch
                                               -> Paged
                                               -> ExceptT
                                                    BlockfrostError
                                                    (ReaderT (ClientEnv, Project) IO)
                                                    [EpochInfo])
                                              :<|> (Epoch
                                                    -> Paged
                                                    -> ExceptT
                                                         BlockfrostError
                                                         (ReaderT (ClientEnv, Project) IO)
                                                         [EpochInfo]))))
                                 :<|> (((Epoch
                                         -> Paged
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [StakeDistribution])
                                        :<|> (Epoch
                                              -> PoolId
                                              -> Paged
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [StakeDistribution]))
                                       :<|> ((Epoch
                                              -> Paged
                                              -> SortOrder
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [BlockHash])
                                             :<|> ((Epoch
                                                    -> PoolId
                                                    -> Paged
                                                    -> SortOrder
                                                    -> ExceptT
                                                         BlockfrostError
                                                         (ReaderT (ClientEnv, Project) IO)
                                                         [BlockHash])
                                                   :<|> (Epoch
                                                         -> ExceptT
                                                              BlockfrostError
                                                              (ReaderT (ClientEnv, Project) IO)
                                                              ProtocolParams))))))))
              :<|> ((ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) Genesis
                     :<|> (((Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMeta])
                            :<|> ((Text
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TxMetaJSON])
                                  :<|> (Text
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [TxMetaCBOR])))
                           :<|> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) Network))
                    :<|> (((((Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolId])
                             :<|> (Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [PoolEpoch]))
                            :<|> ((Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [PoolEpoch])
                                  :<|> ((PoolId
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              PoolInfo)
                                        :<|> (PoolId
                                              -> Paged
                                              -> SortOrder
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [PoolHistory]))))
                           :<|> (((PoolId
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        (Maybe PoolMetadata))
                                  :<|> (PoolId
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [PoolRelay]))
                                 :<|> ((PoolId
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [PoolDelegator])
                                       :<|> ((PoolId
                                              -> Paged
                                              -> SortOrder
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [BlockHash])
                                             :<|> (PoolId
                                                   -> Paged
                                                   -> SortOrder
                                                   -> ExceptT
                                                        BlockfrostError
                                                        (ReaderT (ClientEnv, Project) IO)
                                                        [PoolUpdate])))))
                          :<|> (((((TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         Transaction)
                                   :<|> (TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              TransactionUtxos))
                                  :<|> ((TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionStake])
                                        :<|> ((TxHash
                                               -> ExceptT
                                                    BlockfrostError
                                                    (ReaderT (ClientEnv, Project) IO)
                                                    [TransactionDelegation])
                                              :<|> (TxHash
                                                    -> ExceptT
                                                         BlockfrostError
                                                         (ReaderT (ClientEnv, Project) IO)
                                                         [TransactionWithdrawal]))))
                                 :<|> (((TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionMir])
                                        :<|> (TxHash
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [TransactionPoolUpdate]))
                                       :<|> ((TxHash
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [TransactionPoolRetiring])
                                             :<|> ((TxHash
                                                    -> ExceptT
                                                         BlockfrostError
                                                         (ReaderT (ClientEnv, Project) IO)
                                                         [TransactionMetaJSON])
                                                   :<|> (TxHash
                                                         -> ExceptT
                                                              BlockfrostError
                                                              (ReaderT (ClientEnv, Project) IO)
                                                              [TransactionMetaCBOR])))))
                                :<|> (CBORString
                                      -> ExceptT
                                           BlockfrostError
                                           (ReaderT (ClientEnv, Project) IO)
                                           TxHash))))))
       :<|> (((((ByteString, Form)
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSAdd)
               :<|> ((Text
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSData)
                     :<|> (Text
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
              :<|> ((Paged
                     -> SortOrder
                     -> ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) [IPFSPin])
                    :<|> ((Text
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPin)
                          :<|> (Text
                                -> ExceptT
                                     BlockfrostError
                                     (ReaderT (ClientEnv, Project) IO)
                                     IPFSPinChange))))
             :<|> (((Address
                     -> ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) NutlinkAddress)
                    :<|> (Address
                          -> Paged
                          -> SortOrder
                          -> ExceptT
                               BlockfrostError
                               (ReaderT (ClientEnv, Project) IO)
                               [NutlinkAddressTicker]))
                   :<|> ((Address
                          -> Text
                          -> Paged
                          -> SortOrder
                          -> ExceptT
                               BlockfrostError (ReaderT (ClientEnv, Project) IO) [NutlinkTicker])
                         :<|> (Text
                               -> Paged
                               -> SortOrder
                               -> ExceptT
                                    BlockfrostError
                                    (ReaderT (ClientEnv, Project) IO)
                                    [(Address, NutlinkTicker)])))))
-> Project
-> BlockfrostV0API (AsClientT BlockfrostClient)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockfrostAPI (AsClientT BlockfrostClient)
-> AsClientT BlockfrostClient
   :- ("api"
       :> ("v0" :> (BlockfrostAuth :> ToServantApi BlockfrostV0API)))
forall route.
BlockfrostAPI route
-> route
   :- ("api"
       :> ("v0" :> (BlockfrostAuth :> ToServantApi BlockfrostV0API)))
_apiV0 BlockfrostAPI (AsClientT BlockfrostClient)
apiClient

-- ** Client runner

-- | Run @BlockfrostClient@ monad, using provided @Project@
runBlockfrost :: Project
  -> BlockfrostClient a
  -> IO (Either BlockfrostError a)
runBlockfrost :: Project -> BlockfrostClient a -> IO (Either BlockfrostError a)
runBlockfrost Project
proj BlockfrostClient a
act = do
  ClientEnv
env <- Project -> IO ClientEnv
newEnvByProject Project
proj
  (ReaderT (ClientEnv, Project) IO (Either BlockfrostError a)
 -> (ClientEnv, Project) -> IO (Either BlockfrostError a))
-> (ClientEnv, Project)
-> ReaderT (ClientEnv, Project) IO (Either BlockfrostError a)
-> IO (Either BlockfrostError a)
forall a b c. (a -> b -> c) -> b -> a -> c
flip ReaderT (ClientEnv, Project) IO (Either BlockfrostError a)
-> (ClientEnv, Project) -> IO (Either BlockfrostError a)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (ClientEnv
env, Project
proj)
    (ReaderT (ClientEnv, Project) IO (Either BlockfrostError a)
 -> IO (Either BlockfrostError a))
-> ReaderT (ClientEnv, Project) IO (Either BlockfrostError a)
-> IO (Either BlockfrostError a)
forall a b. (a -> b) -> a -> b
$ BlockfrostClient a
-> ReaderT (ClientEnv, Project) IO (Either BlockfrostError a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT BlockfrostClient a
act

-- | Helper
go :: (Project -> BlockfrostClient a)
  -> BlockfrostClient a
go :: (Project -> BlockfrostClient a) -> BlockfrostClient a
go Project -> BlockfrostClient a
act = ExceptT
  BlockfrostError
  (ReaderT (ClientEnv, Project) IO)
  (ClientEnv, Project)
forall r (m :: * -> *). MonadReader r m => m r
ask ExceptT
  BlockfrostError
  (ReaderT (ClientEnv, Project) IO)
  (ClientEnv, Project)
-> ((ClientEnv, Project) -> BlockfrostClient a)
-> BlockfrostClient a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Project -> BlockfrostClient a
act  (Project -> BlockfrostClient a)
-> ((ClientEnv, Project) -> Project)
-> (ClientEnv, Project)
-> BlockfrostClient a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ClientEnv, Project) -> Project
forall a b. (a, b) -> b
snd

-- Until mtl > 2.2.2
-- https://github.com/haskell/mtl/pull/66
#if !MIN_VERSION_mtl(2,3,0)
-- | 'MonadError' analogue to the 'Control.Exception.try' function.
tryError :: MonadError e m => m a -> m (Either e a)
tryError :: m a -> m (Either e a)
tryError m a
action = (a -> Either e a
forall a b. b -> Either a b
Right (a -> Either e a) -> m a -> m (Either e a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a
action) m (Either e a) -> (e -> m (Either e a)) -> m (Either e a)
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
`catchError` (Either e a -> m (Either e a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either e a -> m (Either e a))
-> (e -> Either e a) -> e -> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Either e a
forall a b. a -> Either a b
Left)
#endif

-- ** Service clients

commonClient :: Project -> CommonAPI (AsClientT BlockfrostClient)
commonClient :: Project -> CommonAPI (AsClientT BlockfrostClient)
commonClient = ((ExceptT
    BlockfrostError (ReaderT (ClientEnv, Project) IO) URLVersion
  :<|> ExceptT
         BlockfrostError (ReaderT (ClientEnv, Project) IO) Healthy)
 :<|> (ExceptT
         BlockfrostError (ReaderT (ClientEnv, Project) IO) ServerTime
       :<|> (ExceptT
               BlockfrostError (ReaderT (ClientEnv, Project) IO) [Metric]
             :<|> ExceptT
                    BlockfrostError
                    (ReaderT (ClientEnv, Project) IO)
                    [(Text, Metric)])))
-> CommonAPI (AsClientT BlockfrostClient)
forall (routes :: * -> *) mode.
GenericServant routes mode =>
ToServant routes mode -> routes mode
fromServant (((ExceptT
     BlockfrostError (ReaderT (ClientEnv, Project) IO) URLVersion
   :<|> ExceptT
          BlockfrostError (ReaderT (ClientEnv, Project) IO) Healthy)
  :<|> (ExceptT
          BlockfrostError (ReaderT (ClientEnv, Project) IO) ServerTime
        :<|> (ExceptT
                BlockfrostError (ReaderT (ClientEnv, Project) IO) [Metric]
              :<|> ExceptT
                     BlockfrostError
                     (ReaderT (ClientEnv, Project) IO)
                     [(Text, Metric)])))
 -> CommonAPI (AsClientT BlockfrostClient))
-> (Project
    -> (ExceptT
          BlockfrostError (ReaderT (ClientEnv, Project) IO) URLVersion
        :<|> ExceptT
               BlockfrostError (ReaderT (ClientEnv, Project) IO) Healthy)
       :<|> (ExceptT
               BlockfrostError (ReaderT (ClientEnv, Project) IO) ServerTime
             :<|> (ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) [Metric]
                   :<|> ExceptT
                          BlockfrostError
                          (ReaderT (ClientEnv, Project) IO)
                          [(Text, Metric)])))
-> Project
-> CommonAPI (AsClientT BlockfrostClient)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockfrostV0API (AsClientT BlockfrostClient)
-> (ExceptT
      BlockfrostError (ReaderT (ClientEnv, Project) IO) URLVersion
    :<|> ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) Healthy)
   :<|> (ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) ServerTime
         :<|> (ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [Metric]
               :<|> ExceptT
                      BlockfrostError
                      (ReaderT (ClientEnv, Project) IO)
                      [(Text, Metric)]))
forall route.
BlockfrostV0API route -> route :- ToServantApi CommonAPI
_common (BlockfrostV0API (AsClientT BlockfrostClient)
 -> (ExceptT
       BlockfrostError (ReaderT (ClientEnv, Project) IO) URLVersion
     :<|> ExceptT
            BlockfrostError (ReaderT (ClientEnv, Project) IO) Healthy)
    :<|> (ExceptT
            BlockfrostError (ReaderT (ClientEnv, Project) IO) ServerTime
          :<|> (ExceptT
                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [Metric]
                :<|> ExceptT
                       BlockfrostError
                       (ReaderT (ClientEnv, Project) IO)
                       [(Text, Metric)])))
-> (Project -> BlockfrostV0API (AsClientT BlockfrostClient))
-> Project
-> (ExceptT
      BlockfrostError (ReaderT (ClientEnv, Project) IO) URLVersion
    :<|> ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) Healthy)
   :<|> (ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) ServerTime
         :<|> (ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [Metric]
               :<|> ExceptT
                      BlockfrostError
                      (ReaderT (ClientEnv, Project) IO)
                      [(Text, Metric)]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Project -> BlockfrostV0API (AsClientT BlockfrostClient)
api0Client

cardanoClient :: Project -> CardanoAPI (AsClientT BlockfrostClient)
cardanoClient :: Project -> CardanoAPI (AsClientT BlockfrostClient)
cardanoClient = ((((((Address
      -> ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) AccountInfo)
     :<|> ((Address
            -> Paged
            -> SortOrder
            -> ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountReward])
           :<|> (Address
                 -> Paged
                 -> SortOrder
                 -> ExceptT
                      BlockfrostError
                      (ReaderT (ClientEnv, Project) IO)
                      [AccountHistory])))
    :<|> (((Address
            -> Paged
            -> SortOrder
            -> ExceptT
                 BlockfrostError
                 (ReaderT (ClientEnv, Project) IO)
                 [AccountDelegation])
           :<|> (Address
                 -> Paged
                 -> SortOrder
                 -> ExceptT
                      BlockfrostError
                      (ReaderT (ClientEnv, Project) IO)
                      [AccountRegistration]))
          :<|> ((Address
                 -> Paged
                 -> SortOrder
                 -> ExceptT
                      BlockfrostError
                      (ReaderT (ClientEnv, Project) IO)
                      [AccountWithdrawal])
                :<|> (Address
                      -> Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountMir]))))
   :<|> (((Address
           -> ExceptT
                BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressInfo)
          :<|> (Address
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressDetails))
         :<|> ((Address
                -> Paged
                -> SortOrder
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) [AddressUTXO])
               :<|> (Address
                     -> Paged
                     -> SortOrder
                     -> Maybe BlockIndex
                     -> Maybe BlockIndex
                     -> ExceptT
                          BlockfrostError
                          (ReaderT (ClientEnv, Project) IO)
                          [AddressTransaction]))))
  :<|> ((((Paged
           -> SortOrder
           -> ExceptT
                BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo])
          :<|> ((AssetId
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) AssetDetails)
                :<|> (AssetId
                      -> Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetHistory])))
         :<|> ((AssetId
                -> Paged
                -> SortOrder
                -> ExceptT
                     BlockfrostError
                     (ReaderT (ClientEnv, Project) IO)
                     [AssetTransaction])
               :<|> ((AssetId
                      -> Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetAddress])
                     :<|> (PolicyId
                           -> Paged
                           -> SortOrder
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo]))))
        :<|> ((((ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) Block
                 :<|> (Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxHash]))
                :<|> ((Either Integer BlockHash
                       -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                      :<|> (Slot
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)))
               :<|> (((Epoch
                       -> Slot
                       -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                      :<|> (Either Integer BlockHash
                            -> Paged
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block]))
                     :<|> ((Either Integer BlockHash
                            -> Paged
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block])
                           :<|> (Either Integer BlockHash
                                 -> Paged
                                 -> SortOrder
                                 -> ExceptT
                                      BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxHash]))))
              :<|> (((ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo
                      :<|> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) ProtocolParams)
                     :<|> ((Epoch
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo)
                           :<|> ((Epoch
                                  -> Paged
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [EpochInfo])
                                 :<|> (Epoch
                                       -> Paged
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [EpochInfo]))))
                    :<|> (((Epoch
                            -> Paged
                            -> ExceptT
                                 BlockfrostError
                                 (ReaderT (ClientEnv, Project) IO)
                                 [StakeDistribution])
                           :<|> (Epoch
                                 -> PoolId
                                 -> Paged
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      [StakeDistribution]))
                          :<|> ((Epoch
                                 -> Paged
                                 -> SortOrder
                                 -> ExceptT
                                      BlockfrostError (ReaderT (ClientEnv, Project) IO) [BlockHash])
                                :<|> ((Epoch
                                       -> PoolId
                                       -> Paged
                                       -> SortOrder
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [BlockHash])
                                      :<|> (Epoch
                                            -> ExceptT
                                                 BlockfrostError
                                                 (ReaderT (ClientEnv, Project) IO)
                                                 ProtocolParams))))))))
 :<|> ((ExceptT
          BlockfrostError (ReaderT (ClientEnv, Project) IO) Genesis
        :<|> (((Paged
                -> SortOrder
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMeta])
               :<|> ((Text
                      -> Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaJSON])
                     :<|> (Text
                           -> Paged
                           -> SortOrder
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaCBOR])))
              :<|> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) Network))
       :<|> (((((Paged
                 -> SortOrder
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolId])
                :<|> (Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch]))
               :<|> ((Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch])
                     :<|> ((PoolId
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) PoolInfo)
                           :<|> (PoolId
                                 -> Paged
                                 -> SortOrder
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      [PoolHistory]))))
              :<|> (((PoolId
                      -> ExceptT
                           BlockfrostError
                           (ReaderT (ClientEnv, Project) IO)
                           (Maybe PoolMetadata))
                     :<|> (PoolId
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolRelay]))
                    :<|> ((PoolId
                           -> Paged
                           -> SortOrder
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolDelegator])
                          :<|> ((PoolId
                                 -> Paged
                                 -> SortOrder
                                 -> ExceptT
                                      BlockfrostError (ReaderT (ClientEnv, Project) IO) [BlockHash])
                                :<|> (PoolId
                                      -> Paged
                                      -> SortOrder
                                      -> ExceptT
                                           BlockfrostError
                                           (ReaderT (ClientEnv, Project) IO)
                                           [PoolUpdate])))))
             :<|> (((((TxHash
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                      :<|> (TxHash
                            -> ExceptT
                                 BlockfrostError
                                 (ReaderT (ClientEnv, Project) IO)
                                 TransactionUtxos))
                     :<|> ((TxHash
                            -> ExceptT
                                 BlockfrostError
                                 (ReaderT (ClientEnv, Project) IO)
                                 [TransactionStake])
                           :<|> ((TxHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [TransactionDelegation])
                                 :<|> (TxHash
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [TransactionWithdrawal]))))
                    :<|> (((TxHash
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [TransactionMir])
                           :<|> (TxHash
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      [TransactionPoolUpdate]))
                          :<|> ((TxHash
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      [TransactionPoolRetiring])
                                :<|> ((TxHash
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [TransactionMetaJSON])
                                      :<|> (TxHash
                                            -> ExceptT
                                                 BlockfrostError
                                                 (ReaderT (ClientEnv, Project) IO)
                                                 [TransactionMetaCBOR])))))
                   :<|> (CBORString
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) TxHash)))))
-> CardanoAPI (AsClientT BlockfrostClient)
forall (routes :: * -> *) mode.
GenericServant routes mode =>
ToServant routes mode -> routes mode
fromServant (((((((Address
       -> ExceptT
            BlockfrostError (ReaderT (ClientEnv, Project) IO) AccountInfo)
      :<|> ((Address
             -> Paged
             -> SortOrder
             -> ExceptT
                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountReward])
            :<|> (Address
                  -> Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError
                       (ReaderT (ClientEnv, Project) IO)
                       [AccountHistory])))
     :<|> (((Address
             -> Paged
             -> SortOrder
             -> ExceptT
                  BlockfrostError
                  (ReaderT (ClientEnv, Project) IO)
                  [AccountDelegation])
            :<|> (Address
                  -> Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError
                       (ReaderT (ClientEnv, Project) IO)
                       [AccountRegistration]))
           :<|> ((Address
                  -> Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError
                       (ReaderT (ClientEnv, Project) IO)
                       [AccountWithdrawal])
                 :<|> (Address
                       -> Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountMir]))))
    :<|> (((Address
            -> ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressInfo)
           :<|> (Address
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressDetails))
          :<|> ((Address
                 -> Paged
                 -> SortOrder
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) [AddressUTXO])
                :<|> (Address
                      -> Paged
                      -> SortOrder
                      -> Maybe BlockIndex
                      -> Maybe BlockIndex
                      -> ExceptT
                           BlockfrostError
                           (ReaderT (ClientEnv, Project) IO)
                           [AddressTransaction]))))
   :<|> ((((Paged
            -> SortOrder
            -> ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo])
           :<|> ((AssetId
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) AssetDetails)
                 :<|> (AssetId
                       -> Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetHistory])))
          :<|> ((AssetId
                 -> Paged
                 -> SortOrder
                 -> ExceptT
                      BlockfrostError
                      (ReaderT (ClientEnv, Project) IO)
                      [AssetTransaction])
                :<|> ((AssetId
                       -> Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetAddress])
                      :<|> (PolicyId
                            -> Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo]))))
         :<|> ((((ExceptT
                    BlockfrostError (ReaderT (ClientEnv, Project) IO) Block
                  :<|> (Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxHash]))
                 :<|> ((Either Integer BlockHash
                        -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                       :<|> (Slot
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)))
                :<|> (((Epoch
                        -> Slot
                        -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                       :<|> (Either Integer BlockHash
                             -> Paged
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block]))
                      :<|> ((Either Integer BlockHash
                             -> Paged
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block])
                            :<|> (Either Integer BlockHash
                                  -> Paged
                                  -> SortOrder
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [TxHash]))))
               :<|> (((ExceptT
                         BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo
                       :<|> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) ProtocolParams)
                      :<|> ((Epoch
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo)
                            :<|> ((Epoch
                                   -> Paged
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [EpochInfo])
                                  :<|> (Epoch
                                        -> Paged
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [EpochInfo]))))
                     :<|> (((Epoch
                             -> Paged
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  [StakeDistribution])
                            :<|> (Epoch
                                  -> PoolId
                                  -> Paged
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [StakeDistribution]))
                           :<|> ((Epoch
                                  -> Paged
                                  -> SortOrder
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [BlockHash])
                                 :<|> ((Epoch
                                        -> PoolId
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [BlockHash])
                                       :<|> (Epoch
                                             -> ExceptT
                                                  BlockfrostError
                                                  (ReaderT (ClientEnv, Project) IO)
                                                  ProtocolParams))))))))
  :<|> ((ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) Genesis
         :<|> (((Paged
                 -> SortOrder
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMeta])
                :<|> ((Text
                       -> Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaJSON])
                      :<|> (Text
                            -> Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaCBOR])))
               :<|> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) Network))
        :<|> (((((Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolId])
                 :<|> (Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch]))
                :<|> ((Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch])
                      :<|> ((PoolId
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) PoolInfo)
                            :<|> (PoolId
                                  -> Paged
                                  -> SortOrder
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [PoolHistory]))))
               :<|> (((PoolId
                       -> ExceptT
                            BlockfrostError
                            (ReaderT (ClientEnv, Project) IO)
                            (Maybe PoolMetadata))
                      :<|> (PoolId
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolRelay]))
                     :<|> ((PoolId
                            -> Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolDelegator])
                           :<|> ((PoolId
                                  -> Paged
                                  -> SortOrder
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [BlockHash])
                                 :<|> (PoolId
                                       -> Paged
                                       -> SortOrder
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [PoolUpdate])))))
              :<|> (((((TxHash
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                       :<|> (TxHash
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  TransactionUtxos))
                      :<|> ((TxHash
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  [TransactionStake])
                            :<|> ((TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TransactionDelegation])
                                  :<|> (TxHash
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [TransactionWithdrawal]))))
                     :<|> (((TxHash
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  [TransactionMir])
                            :<|> (TxHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [TransactionPoolUpdate]))
                           :<|> ((TxHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [TransactionPoolRetiring])
                                 :<|> ((TxHash
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [TransactionMetaJSON])
                                       :<|> (TxHash
                                             -> ExceptT
                                                  BlockfrostError
                                                  (ReaderT (ClientEnv, Project) IO)
                                                  [TransactionMetaCBOR])))))
                    :<|> (CBORString
                          -> ExceptT
                               BlockfrostError (ReaderT (ClientEnv, Project) IO) TxHash)))))
 -> CardanoAPI (AsClientT BlockfrostClient))
-> (Project
    -> (((((Address
            -> ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) AccountInfo)
           :<|> ((Address
                  -> Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountReward])
                 :<|> (Address
                       -> Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError
                            (ReaderT (ClientEnv, Project) IO)
                            [AccountHistory])))
          :<|> (((Address
                  -> Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError
                       (ReaderT (ClientEnv, Project) IO)
                       [AccountDelegation])
                 :<|> (Address
                       -> Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError
                            (ReaderT (ClientEnv, Project) IO)
                            [AccountRegistration]))
                :<|> ((Address
                       -> Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError
                            (ReaderT (ClientEnv, Project) IO)
                            [AccountWithdrawal])
                      :<|> (Address
                            -> Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountMir]))))
         :<|> (((Address
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressInfo)
                :<|> (Address
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressDetails))
               :<|> ((Address
                      -> Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) [AddressUTXO])
                     :<|> (Address
                           -> Paged
                           -> SortOrder
                           -> Maybe BlockIndex
                           -> Maybe BlockIndex
                           -> ExceptT
                                BlockfrostError
                                (ReaderT (ClientEnv, Project) IO)
                                [AddressTransaction]))))
        :<|> ((((Paged
                 -> SortOrder
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo])
                :<|> ((AssetId
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) AssetDetails)
                      :<|> (AssetId
                            -> Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetHistory])))
               :<|> ((AssetId
                      -> Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError
                           (ReaderT (ClientEnv, Project) IO)
                           [AssetTransaction])
                     :<|> ((AssetId
                            -> Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetAddress])
                           :<|> (PolicyId
                                 -> Paged
                                 -> SortOrder
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      [AssetInfo]))))
              :<|> ((((ExceptT
                         BlockfrostError (ReaderT (ClientEnv, Project) IO) Block
                       :<|> (Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxHash]))
                      :<|> ((Either Integer BlockHash
                             -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                            :<|> (Slot
                                  -> ExceptT
                                       BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)))
                     :<|> (((Epoch
                             -> Slot
                             -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                            :<|> (Either Integer BlockHash
                                  -> Paged
                                  -> ExceptT
                                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block]))
                           :<|> ((Either Integer BlockHash
                                  -> Paged
                                  -> ExceptT
                                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block])
                                 :<|> (Either Integer BlockHash
                                       -> Paged
                                       -> SortOrder
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [TxHash]))))
                    :<|> (((ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo
                            :<|> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) ProtocolParams)
                           :<|> ((Epoch
                                  -> ExceptT
                                       BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo)
                                 :<|> ((Epoch
                                        -> Paged
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [EpochInfo])
                                       :<|> (Epoch
                                             -> Paged
                                             -> ExceptT
                                                  BlockfrostError
                                                  (ReaderT (ClientEnv, Project) IO)
                                                  [EpochInfo]))))
                          :<|> (((Epoch
                                  -> Paged
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [StakeDistribution])
                                 :<|> (Epoch
                                       -> PoolId
                                       -> Paged
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [StakeDistribution]))
                                :<|> ((Epoch
                                       -> Paged
                                       -> SortOrder
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [BlockHash])
                                      :<|> ((Epoch
                                             -> PoolId
                                             -> Paged
                                             -> SortOrder
                                             -> ExceptT
                                                  BlockfrostError
                                                  (ReaderT (ClientEnv, Project) IO)
                                                  [BlockHash])
                                            :<|> (Epoch
                                                  -> ExceptT
                                                       BlockfrostError
                                                       (ReaderT (ClientEnv, Project) IO)
                                                       ProtocolParams))))))))
       :<|> ((ExceptT
                BlockfrostError (ReaderT (ClientEnv, Project) IO) Genesis
              :<|> (((Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMeta])
                     :<|> ((Text
                            -> Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaJSON])
                           :<|> (Text
                                 -> Paged
                                 -> SortOrder
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      [TxMetaCBOR])))
                    :<|> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) Network))
             :<|> (((((Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolId])
                      :<|> (Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch]))
                     :<|> ((Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch])
                           :<|> ((PoolId
                                  -> ExceptT
                                       BlockfrostError (ReaderT (ClientEnv, Project) IO) PoolInfo)
                                 :<|> (PoolId
                                       -> Paged
                                       -> SortOrder
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [PoolHistory]))))
                    :<|> (((PoolId
                            -> ExceptT
                                 BlockfrostError
                                 (ReaderT (ClientEnv, Project) IO)
                                 (Maybe PoolMetadata))
                           :<|> (PoolId
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      [PoolRelay]))
                          :<|> ((PoolId
                                 -> Paged
                                 -> SortOrder
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      [PoolDelegator])
                                :<|> ((PoolId
                                       -> Paged
                                       -> SortOrder
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [BlockHash])
                                      :<|> (PoolId
                                            -> Paged
                                            -> SortOrder
                                            -> ExceptT
                                                 BlockfrostError
                                                 (ReaderT (ClientEnv, Project) IO)
                                                 [PoolUpdate])))))
                   :<|> (((((TxHash
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                            :<|> (TxHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       TransactionUtxos))
                           :<|> ((TxHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [TransactionStake])
                                 :<|> ((TxHash
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [TransactionDelegation])
                                       :<|> (TxHash
                                             -> ExceptT
                                                  BlockfrostError
                                                  (ReaderT (ClientEnv, Project) IO)
                                                  [TransactionWithdrawal]))))
                          :<|> (((TxHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [TransactionMir])
                                 :<|> (TxHash
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [TransactionPoolUpdate]))
                                :<|> ((TxHash
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            [TransactionPoolRetiring])
                                      :<|> ((TxHash
                                             -> ExceptT
                                                  BlockfrostError
                                                  (ReaderT (ClientEnv, Project) IO)
                                                  [TransactionMetaJSON])
                                            :<|> (TxHash
                                                  -> ExceptT
                                                       BlockfrostError
                                                       (ReaderT (ClientEnv, Project) IO)
                                                       [TransactionMetaCBOR])))))
                         :<|> (CBORString
                               -> ExceptT
                                    BlockfrostError (ReaderT (ClientEnv, Project) IO) TxHash)))))
-> Project
-> CardanoAPI (AsClientT BlockfrostClient)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockfrostV0API (AsClientT BlockfrostClient)
-> (((((Address
        -> ExceptT
             BlockfrostError (ReaderT (ClientEnv, Project) IO) AccountInfo)
       :<|> ((Address
              -> Paged
              -> SortOrder
              -> ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountReward])
             :<|> (Address
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError
                        (ReaderT (ClientEnv, Project) IO)
                        [AccountHistory])))
      :<|> (((Address
              -> Paged
              -> SortOrder
              -> ExceptT
                   BlockfrostError
                   (ReaderT (ClientEnv, Project) IO)
                   [AccountDelegation])
             :<|> (Address
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError
                        (ReaderT (ClientEnv, Project) IO)
                        [AccountRegistration]))
            :<|> ((Address
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError
                        (ReaderT (ClientEnv, Project) IO)
                        [AccountWithdrawal])
                  :<|> (Address
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountMir]))))
     :<|> (((Address
             -> ExceptT
                  BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressInfo)
            :<|> (Address
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressDetails))
           :<|> ((Address
                  -> Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [AddressUTXO])
                 :<|> (Address
                       -> Paged
                       -> SortOrder
                       -> Maybe BlockIndex
                       -> Maybe BlockIndex
                       -> ExceptT
                            BlockfrostError
                            (ReaderT (ClientEnv, Project) IO)
                            [AddressTransaction]))))
    :<|> ((((Paged
             -> SortOrder
             -> ExceptT
                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo])
            :<|> ((AssetId
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) AssetDetails)
                  :<|> (AssetId
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetHistory])))
           :<|> ((AssetId
                  -> Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError
                       (ReaderT (ClientEnv, Project) IO)
                       [AssetTransaction])
                 :<|> ((AssetId
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetAddress])
                       :<|> (PolicyId
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo]))))
          :<|> ((((ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) Block
                   :<|> (Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxHash]))
                  :<|> ((Either Integer BlockHash
                         -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                        :<|> (Slot
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)))
                 :<|> (((Epoch
                         -> Slot
                         -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                        :<|> (Either Integer BlockHash
                              -> Paged
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block]))
                       :<|> ((Either Integer BlockHash
                              -> Paged
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block])
                             :<|> (Either Integer BlockHash
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TxHash]))))
                :<|> (((ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo
                        :<|> ExceptT
                               BlockfrostError (ReaderT (ClientEnv, Project) IO) ProtocolParams)
                       :<|> ((Epoch
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo)
                             :<|> ((Epoch
                                    -> Paged
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [EpochInfo])
                                   :<|> (Epoch
                                         -> Paged
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [EpochInfo]))))
                      :<|> (((Epoch
                              -> Paged
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [StakeDistribution])
                             :<|> (Epoch
                                   -> PoolId
                                   -> Paged
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [StakeDistribution]))
                            :<|> ((Epoch
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [BlockHash])
                                  :<|> ((Epoch
                                         -> PoolId
                                         -> Paged
                                         -> SortOrder
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [BlockHash])
                                        :<|> (Epoch
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   ProtocolParams))))))))
   :<|> ((ExceptT
            BlockfrostError (ReaderT (ClientEnv, Project) IO) Genesis
          :<|> (((Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMeta])
                 :<|> ((Text
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaJSON])
                       :<|> (Text
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaCBOR])))
                :<|> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) Network))
         :<|> (((((Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolId])
                  :<|> (Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch]))
                 :<|> ((Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch])
                       :<|> ((PoolId
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) PoolInfo)
                             :<|> (PoolId
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [PoolHistory]))))
                :<|> (((PoolId
                        -> ExceptT
                             BlockfrostError
                             (ReaderT (ClientEnv, Project) IO)
                             (Maybe PoolMetadata))
                       :<|> (PoolId
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolRelay]))
                      :<|> ((PoolId
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolDelegator])
                            :<|> ((PoolId
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [BlockHash])
                                  :<|> (PoolId
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [PoolUpdate])))))
               :<|> (((((TxHash
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                        :<|> (TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   TransactionUtxos))
                       :<|> ((TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [TransactionStake])
                             :<|> ((TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [TransactionDelegation])
                                   :<|> (TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionWithdrawal]))))
                      :<|> (((TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [TransactionMir])
                             :<|> (TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TransactionPoolUpdate]))
                            :<|> ((TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TransactionPoolRetiring])
                                  :<|> ((TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionMetaJSON])
                                        :<|> (TxHash
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [TransactionMetaCBOR])))))
                     :<|> (CBORString
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) TxHash))))
forall route.
BlockfrostV0API route -> route :- ToServantApi CardanoAPI
_cardano (BlockfrostV0API (AsClientT BlockfrostClient)
 -> (((((Address
         -> ExceptT
              BlockfrostError (ReaderT (ClientEnv, Project) IO) AccountInfo)
        :<|> ((Address
               -> Paged
               -> SortOrder
               -> ExceptT
                    BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountReward])
              :<|> (Address
                    -> Paged
                    -> SortOrder
                    -> ExceptT
                         BlockfrostError
                         (ReaderT (ClientEnv, Project) IO)
                         [AccountHistory])))
       :<|> (((Address
               -> Paged
               -> SortOrder
               -> ExceptT
                    BlockfrostError
                    (ReaderT (ClientEnv, Project) IO)
                    [AccountDelegation])
              :<|> (Address
                    -> Paged
                    -> SortOrder
                    -> ExceptT
                         BlockfrostError
                         (ReaderT (ClientEnv, Project) IO)
                         [AccountRegistration]))
             :<|> ((Address
                    -> Paged
                    -> SortOrder
                    -> ExceptT
                         BlockfrostError
                         (ReaderT (ClientEnv, Project) IO)
                         [AccountWithdrawal])
                   :<|> (Address
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountMir]))))
      :<|> (((Address
              -> ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressInfo)
             :<|> (Address
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressDetails))
            :<|> ((Address
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) [AddressUTXO])
                  :<|> (Address
                        -> Paged
                        -> SortOrder
                        -> Maybe BlockIndex
                        -> Maybe BlockIndex
                        -> ExceptT
                             BlockfrostError
                             (ReaderT (ClientEnv, Project) IO)
                             [AddressTransaction]))))
     :<|> ((((Paged
              -> SortOrder
              -> ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo])
             :<|> ((AssetId
                    -> ExceptT
                         BlockfrostError (ReaderT (ClientEnv, Project) IO) AssetDetails)
                   :<|> (AssetId
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetHistory])))
            :<|> ((AssetId
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError
                        (ReaderT (ClientEnv, Project) IO)
                        [AssetTransaction])
                  :<|> ((AssetId
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetAddress])
                        :<|> (PolicyId
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo]))))
           :<|> ((((ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) Block
                    :<|> (Paged
                          -> SortOrder
                          -> ExceptT
                               BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxHash]))
                   :<|> ((Either Integer BlockHash
                          -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                         :<|> (Slot
                               -> ExceptT
                                    BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)))
                  :<|> (((Epoch
                          -> Slot
                          -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                         :<|> (Either Integer BlockHash
                               -> Paged
                               -> ExceptT
                                    BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block]))
                        :<|> ((Either Integer BlockHash
                               -> Paged
                               -> ExceptT
                                    BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block])
                              :<|> (Either Integer BlockHash
                                    -> Paged
                                    -> SortOrder
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [TxHash]))))
                 :<|> (((ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo
                         :<|> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) ProtocolParams)
                        :<|> ((Epoch
                               -> ExceptT
                                    BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo)
                              :<|> ((Epoch
                                     -> Paged
                                     -> ExceptT
                                          BlockfrostError
                                          (ReaderT (ClientEnv, Project) IO)
                                          [EpochInfo])
                                    :<|> (Epoch
                                          -> Paged
                                          -> ExceptT
                                               BlockfrostError
                                               (ReaderT (ClientEnv, Project) IO)
                                               [EpochInfo]))))
                       :<|> (((Epoch
                               -> Paged
                               -> ExceptT
                                    BlockfrostError
                                    (ReaderT (ClientEnv, Project) IO)
                                    [StakeDistribution])
                              :<|> (Epoch
                                    -> PoolId
                                    -> Paged
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [StakeDistribution]))
                             :<|> ((Epoch
                                    -> Paged
                                    -> SortOrder
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [BlockHash])
                                   :<|> ((Epoch
                                          -> PoolId
                                          -> Paged
                                          -> SortOrder
                                          -> ExceptT
                                               BlockfrostError
                                               (ReaderT (ClientEnv, Project) IO)
                                               [BlockHash])
                                         :<|> (Epoch
                                               -> ExceptT
                                                    BlockfrostError
                                                    (ReaderT (ClientEnv, Project) IO)
                                                    ProtocolParams))))))))
    :<|> ((ExceptT
             BlockfrostError (ReaderT (ClientEnv, Project) IO) Genesis
           :<|> (((Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMeta])
                  :<|> ((Text
                         -> Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaJSON])
                        :<|> (Text
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaCBOR])))
                 :<|> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) Network))
          :<|> (((((Paged
                    -> SortOrder
                    -> ExceptT
                         BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolId])
                   :<|> (Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch]))
                  :<|> ((Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch])
                        :<|> ((PoolId
                               -> ExceptT
                                    BlockfrostError (ReaderT (ClientEnv, Project) IO) PoolInfo)
                              :<|> (PoolId
                                    -> Paged
                                    -> SortOrder
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [PoolHistory]))))
                 :<|> (((PoolId
                         -> ExceptT
                              BlockfrostError
                              (ReaderT (ClientEnv, Project) IO)
                              (Maybe PoolMetadata))
                        :<|> (PoolId
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolRelay]))
                       :<|> ((PoolId
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [PoolDelegator])
                             :<|> ((PoolId
                                    -> Paged
                                    -> SortOrder
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [BlockHash])
                                   :<|> (PoolId
                                         -> Paged
                                         -> SortOrder
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [PoolUpdate])))))
                :<|> (((((TxHash
                          -> ExceptT
                               BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                         :<|> (TxHash
                               -> ExceptT
                                    BlockfrostError
                                    (ReaderT (ClientEnv, Project) IO)
                                    TransactionUtxos))
                        :<|> ((TxHash
                               -> ExceptT
                                    BlockfrostError
                                    (ReaderT (ClientEnv, Project) IO)
                                    [TransactionStake])
                              :<|> ((TxHash
                                     -> ExceptT
                                          BlockfrostError
                                          (ReaderT (ClientEnv, Project) IO)
                                          [TransactionDelegation])
                                    :<|> (TxHash
                                          -> ExceptT
                                               BlockfrostError
                                               (ReaderT (ClientEnv, Project) IO)
                                               [TransactionWithdrawal]))))
                       :<|> (((TxHash
                               -> ExceptT
                                    BlockfrostError
                                    (ReaderT (ClientEnv, Project) IO)
                                    [TransactionMir])
                              :<|> (TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [TransactionPoolUpdate]))
                             :<|> ((TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [TransactionPoolRetiring])
                                   :<|> ((TxHash
                                          -> ExceptT
                                               BlockfrostError
                                               (ReaderT (ClientEnv, Project) IO)
                                               [TransactionMetaJSON])
                                         :<|> (TxHash
                                               -> ExceptT
                                                    BlockfrostError
                                                    (ReaderT (ClientEnv, Project) IO)
                                                    [TransactionMetaCBOR])))))
                      :<|> (CBORString
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) TxHash)))))
-> (Project -> BlockfrostV0API (AsClientT BlockfrostClient))
-> Project
-> (((((Address
        -> ExceptT
             BlockfrostError (ReaderT (ClientEnv, Project) IO) AccountInfo)
       :<|> ((Address
              -> Paged
              -> SortOrder
              -> ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountReward])
             :<|> (Address
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError
                        (ReaderT (ClientEnv, Project) IO)
                        [AccountHistory])))
      :<|> (((Address
              -> Paged
              -> SortOrder
              -> ExceptT
                   BlockfrostError
                   (ReaderT (ClientEnv, Project) IO)
                   [AccountDelegation])
             :<|> (Address
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError
                        (ReaderT (ClientEnv, Project) IO)
                        [AccountRegistration]))
            :<|> ((Address
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError
                        (ReaderT (ClientEnv, Project) IO)
                        [AccountWithdrawal])
                  :<|> (Address
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [AccountMir]))))
     :<|> (((Address
             -> ExceptT
                  BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressInfo)
            :<|> (Address
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) AddressDetails))
           :<|> ((Address
                  -> Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [AddressUTXO])
                 :<|> (Address
                       -> Paged
                       -> SortOrder
                       -> Maybe BlockIndex
                       -> Maybe BlockIndex
                       -> ExceptT
                            BlockfrostError
                            (ReaderT (ClientEnv, Project) IO)
                            [AddressTransaction]))))
    :<|> ((((Paged
             -> SortOrder
             -> ExceptT
                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo])
            :<|> ((AssetId
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) AssetDetails)
                  :<|> (AssetId
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetHistory])))
           :<|> ((AssetId
                  -> Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError
                       (ReaderT (ClientEnv, Project) IO)
                       [AssetTransaction])
                 :<|> ((AssetId
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetAddress])
                       :<|> (PolicyId
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [AssetInfo]))))
          :<|> ((((ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) Block
                   :<|> (Paged
                         -> SortOrder
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxHash]))
                  :<|> ((Either Integer BlockHash
                         -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                        :<|> (Slot
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)))
                 :<|> (((Epoch
                         -> Slot
                         -> ExceptT BlockfrostError (ReaderT (ClientEnv, Project) IO) Block)
                        :<|> (Either Integer BlockHash
                              -> Paged
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block]))
                       :<|> ((Either Integer BlockHash
                              -> Paged
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [Block])
                             :<|> (Either Integer BlockHash
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TxHash]))))
                :<|> (((ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo
                        :<|> ExceptT
                               BlockfrostError (ReaderT (ClientEnv, Project) IO) ProtocolParams)
                       :<|> ((Epoch
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) EpochInfo)
                             :<|> ((Epoch
                                    -> Paged
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [EpochInfo])
                                   :<|> (Epoch
                                         -> Paged
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [EpochInfo]))))
                      :<|> (((Epoch
                              -> Paged
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [StakeDistribution])
                             :<|> (Epoch
                                   -> PoolId
                                   -> Paged
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [StakeDistribution]))
                            :<|> ((Epoch
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [BlockHash])
                                  :<|> ((Epoch
                                         -> PoolId
                                         -> Paged
                                         -> SortOrder
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [BlockHash])
                                        :<|> (Epoch
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   ProtocolParams))))))))
   :<|> ((ExceptT
            BlockfrostError (ReaderT (ClientEnv, Project) IO) Genesis
          :<|> (((Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMeta])
                 :<|> ((Text
                        -> Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaJSON])
                       :<|> (Text
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [TxMetaCBOR])))
                :<|> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) Network))
         :<|> (((((Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolId])
                  :<|> (Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch]))
                 :<|> ((Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolEpoch])
                       :<|> ((PoolId
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) PoolInfo)
                             :<|> (PoolId
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [PoolHistory]))))
                :<|> (((PoolId
                        -> ExceptT
                             BlockfrostError
                             (ReaderT (ClientEnv, Project) IO)
                             (Maybe PoolMetadata))
                       :<|> (PoolId
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolRelay]))
                      :<|> ((PoolId
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [PoolDelegator])
                            :<|> ((PoolId
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [BlockHash])
                                  :<|> (PoolId
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [PoolUpdate])))))
               :<|> (((((TxHash
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                        :<|> (TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   TransactionUtxos))
                       :<|> ((TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [TransactionStake])
                             :<|> ((TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [TransactionDelegation])
                                   :<|> (TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionWithdrawal]))))
                      :<|> (((TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [TransactionMir])
                             :<|> (TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TransactionPoolUpdate]))
                            :<|> ((TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TransactionPoolRetiring])
                                  :<|> ((TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionMetaJSON])
                                        :<|> (TxHash
                                              -> ExceptT
                                                   BlockfrostError
                                                   (ReaderT (ClientEnv, Project) IO)
                                                   [TransactionMetaCBOR])))))
                     :<|> (CBORString
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) TxHash))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Project -> BlockfrostV0API (AsClientT BlockfrostClient)
api0Client

ipfsClient :: Project -> IPFSAPI (AsClientT BlockfrostClient)
ipfsClient :: Project -> IPFSAPI (AsClientT BlockfrostClient)
ipfsClient = ((((ByteString, Form)
   -> ExceptT
        BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSAdd)
  :<|> ((Text
         -> ExceptT
              BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSData)
        :<|> (Text
              -> ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
 :<|> ((Paged
        -> SortOrder
        -> ExceptT
             BlockfrostError (ReaderT (ClientEnv, Project) IO) [IPFSPin])
       :<|> ((Text
              -> ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPin)
             :<|> (Text
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange))))
-> IPFSAPI (AsClientT BlockfrostClient)
forall (routes :: * -> *) mode.
GenericServant routes mode =>
ToServant routes mode -> routes mode
fromServant (((((ByteString, Form)
    -> ExceptT
         BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSAdd)
   :<|> ((Text
          -> ExceptT
               BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSData)
         :<|> (Text
               -> ExceptT
                    BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
  :<|> ((Paged
         -> SortOrder
         -> ExceptT
              BlockfrostError (ReaderT (ClientEnv, Project) IO) [IPFSPin])
        :<|> ((Text
               -> ExceptT
                    BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPin)
              :<|> (Text
                    -> ExceptT
                         BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange))))
 -> IPFSAPI (AsClientT BlockfrostClient))
-> (Project
    -> (((ByteString, Form)
         -> ExceptT
              BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSAdd)
        :<|> ((Text
               -> ExceptT
                    BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSData)
              :<|> (Text
                    -> ExceptT
                         BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
       :<|> ((Paged
              -> SortOrder
              -> ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [IPFSPin])
             :<|> ((Text
                    -> ExceptT
                         BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPin)
                   :<|> (Text
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange))))
-> Project
-> IPFSAPI (AsClientT BlockfrostClient)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockfrostV0API (AsClientT BlockfrostClient)
-> (((ByteString, Form)
     -> ExceptT
          BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSAdd)
    :<|> ((Text
           -> ExceptT
                BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSData)
          :<|> (Text
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
   :<|> ((Paged
          -> SortOrder
          -> ExceptT
               BlockfrostError (ReaderT (ClientEnv, Project) IO) [IPFSPin])
         :<|> ((Text
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPin)
               :<|> (Text
                     -> ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
forall route.
BlockfrostV0API route -> route :- ("ipfs" :> ToServantApi IPFSAPI)
_ipfs (BlockfrostV0API (AsClientT BlockfrostClient)
 -> (((ByteString, Form)
      -> ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSAdd)
     :<|> ((Text
            -> ExceptT
                 BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSData)
           :<|> (Text
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
    :<|> ((Paged
           -> SortOrder
           -> ExceptT
                BlockfrostError (ReaderT (ClientEnv, Project) IO) [IPFSPin])
          :<|> ((Text
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPin)
                :<|> (Text
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange))))
-> (Project -> BlockfrostV0API (AsClientT BlockfrostClient))
-> Project
-> (((ByteString, Form)
     -> ExceptT
          BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSAdd)
    :<|> ((Text
           -> ExceptT
                BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSData)
          :<|> (Text
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
   :<|> ((Paged
          -> SortOrder
          -> ExceptT
               BlockfrostError (ReaderT (ClientEnv, Project) IO) [IPFSPin])
         :<|> ((Text
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPin)
               :<|> (Text
                     -> ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) IPFSPinChange)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Project -> BlockfrostV0API (AsClientT BlockfrostClient)
api0Client

nutLinkClient :: Project -> NutLinkAPI (AsClientT BlockfrostClient)
nutLinkClient :: Project -> NutLinkAPI (AsClientT BlockfrostClient)
nutLinkClient = (((Address
   -> ExceptT
        BlockfrostError (ReaderT (ClientEnv, Project) IO) NutlinkAddress)
  :<|> (Address
        -> Paged
        -> SortOrder
        -> ExceptT
             BlockfrostError
             (ReaderT (ClientEnv, Project) IO)
             [NutlinkAddressTicker]))
 :<|> ((Address
        -> Text
        -> Paged
        -> SortOrder
        -> ExceptT
             BlockfrostError (ReaderT (ClientEnv, Project) IO) [NutlinkTicker])
       :<|> (Text
             -> Paged
             -> SortOrder
             -> ExceptT
                  BlockfrostError
                  (ReaderT (ClientEnv, Project) IO)
                  [(Address, NutlinkTicker)])))
-> NutLinkAPI (AsClientT BlockfrostClient)
forall (routes :: * -> *) mode.
GenericServant routes mode =>
ToServant routes mode -> routes mode
fromServant ((((Address
    -> ExceptT
         BlockfrostError (ReaderT (ClientEnv, Project) IO) NutlinkAddress)
   :<|> (Address
         -> Paged
         -> SortOrder
         -> ExceptT
              BlockfrostError
              (ReaderT (ClientEnv, Project) IO)
              [NutlinkAddressTicker]))
  :<|> ((Address
         -> Text
         -> Paged
         -> SortOrder
         -> ExceptT
              BlockfrostError (ReaderT (ClientEnv, Project) IO) [NutlinkTicker])
        :<|> (Text
              -> Paged
              -> SortOrder
              -> ExceptT
                   BlockfrostError
                   (ReaderT (ClientEnv, Project) IO)
                   [(Address, NutlinkTicker)])))
 -> NutLinkAPI (AsClientT BlockfrostClient))
-> (Project
    -> ((Address
         -> ExceptT
              BlockfrostError (ReaderT (ClientEnv, Project) IO) NutlinkAddress)
        :<|> (Address
              -> Paged
              -> SortOrder
              -> ExceptT
                   BlockfrostError
                   (ReaderT (ClientEnv, Project) IO)
                   [NutlinkAddressTicker]))
       :<|> ((Address
              -> Text
              -> Paged
              -> SortOrder
              -> ExceptT
                   BlockfrostError (ReaderT (ClientEnv, Project) IO) [NutlinkTicker])
             :<|> (Text
                   -> Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError
                        (ReaderT (ClientEnv, Project) IO)
                        [(Address, NutlinkTicker)])))
-> Project
-> NutLinkAPI (AsClientT BlockfrostClient)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockfrostV0API (AsClientT BlockfrostClient)
-> ((Address
     -> ExceptT
          BlockfrostError (ReaderT (ClientEnv, Project) IO) NutlinkAddress)
    :<|> (Address
          -> Paged
          -> SortOrder
          -> ExceptT
               BlockfrostError
               (ReaderT (ClientEnv, Project) IO)
               [NutlinkAddressTicker]))
   :<|> ((Address
          -> Text
          -> Paged
          -> SortOrder
          -> ExceptT
               BlockfrostError (ReaderT (ClientEnv, Project) IO) [NutlinkTicker])
         :<|> (Text
               -> Paged
               -> SortOrder
               -> ExceptT
                    BlockfrostError
                    (ReaderT (ClientEnv, Project) IO)
                    [(Address, NutlinkTicker)]))
forall route.
BlockfrostV0API route
-> route
   :- ("nutlink" :> (Tag "Nut.link" :> ToServantApi NutLinkAPI))
_nutLink (BlockfrostV0API (AsClientT BlockfrostClient)
 -> ((Address
      -> ExceptT
           BlockfrostError (ReaderT (ClientEnv, Project) IO) NutlinkAddress)
     :<|> (Address
           -> Paged
           -> SortOrder
           -> ExceptT
                BlockfrostError
                (ReaderT (ClientEnv, Project) IO)
                [NutlinkAddressTicker]))
    :<|> ((Address
           -> Text
           -> Paged
           -> SortOrder
           -> ExceptT
                BlockfrostError (ReaderT (ClientEnv, Project) IO) [NutlinkTicker])
          :<|> (Text
                -> Paged
                -> SortOrder
                -> ExceptT
                     BlockfrostError
                     (ReaderT (ClientEnv, Project) IO)
                     [(Address, NutlinkTicker)])))
-> (Project -> BlockfrostV0API (AsClientT BlockfrostClient))
-> Project
-> ((Address
     -> ExceptT
          BlockfrostError (ReaderT (ClientEnv, Project) IO) NutlinkAddress)
    :<|> (Address
          -> Paged
          -> SortOrder
          -> ExceptT
               BlockfrostError
               (ReaderT (ClientEnv, Project) IO)
               [NutlinkAddressTicker]))
   :<|> ((Address
          -> Text
          -> Paged
          -> SortOrder
          -> ExceptT
               BlockfrostError (ReaderT (ClientEnv, Project) IO) [NutlinkTicker])
         :<|> (Text
               -> Paged
               -> SortOrder
               -> ExceptT
                    BlockfrostError
                    (ReaderT (ClientEnv, Project) IO)
                    [(Address, NutlinkTicker)]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Project -> BlockfrostV0API (AsClientT BlockfrostClient)
api0Client