-- | 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
                              -> AssetId
                              -> 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])))))))
              :<|> ((((Paged
                       -> SortOrder
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) [ScriptHash])
                      :<|> ((ScriptHash
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) Script)
                            :<|> (ScriptHash
                                  -> Paged
                                  -> SortOrder
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [ScriptRedeemer])))
                     :<|> ((DatumHash
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptDatum)
                           :<|> ((ScriptHash
                                  -> ExceptT
                                       BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptJSON)
                                 :<|> (ScriptHash
                                       -> ExceptT
                                            BlockfrostError
                                            (ReaderT (ClientEnv, Project) IO)
                                            ScriptCBOR))))
                    :<|> (((((TxHash
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                             :<|> (TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        TransactionUtxos))
                            :<|> ((TxHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [TransactionRedeemer])
                                  :<|> ((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
                               -> AssetId
                               -> 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])))))))
               :<|> ((((Paged
                        -> SortOrder
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) [ScriptHash])
                       :<|> ((ScriptHash
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) Script)
                             :<|> (ScriptHash
                                   -> Paged
                                   -> SortOrder
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        [ScriptRedeemer])))
                      :<|> ((DatumHash
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptDatum)
                            :<|> ((ScriptHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        ScriptJSON)
                                  :<|> (ScriptHash
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             ScriptCBOR))))
                     :<|> (((((TxHash
                               -> ExceptT
                                    BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                              :<|> (TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         TransactionUtxos))
                             :<|> ((TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         [TransactionRedeemer])
                                   :<|> ((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
                                    -> AssetId
                                    -> 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])))))))
                    :<|> ((((Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) [ScriptHash])
                            :<|> ((ScriptHash
                                   -> ExceptT
                                        BlockfrostError (ReaderT (ClientEnv, Project) IO) Script)
                                  :<|> (ScriptHash
                                        -> Paged
                                        -> SortOrder
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             [ScriptRedeemer])))
                           :<|> ((DatumHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       ScriptDatum)
                                 :<|> ((ScriptHash
                                        -> ExceptT
                                             BlockfrostError
                                             (ReaderT (ClientEnv, Project) IO)
                                             ScriptJSON)
                                       :<|> (ScriptHash
                                             -> ExceptT
                                                  BlockfrostError
                                                  (ReaderT (ClientEnv, Project) IO)
                                                  ScriptCBOR))))
                          :<|> (((((TxHash
                                    -> ExceptT
                                         BlockfrostError
                                         (ReaderT (ClientEnv, Project) IO)
                                         Transaction)
                                   :<|> (TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              TransactionUtxos))
                                  :<|> ((TxHash
                                         -> ExceptT
                                              BlockfrostError
                                              (ReaderT (ClientEnv, Project) IO)
                                              [TransactionRedeemer])
                                        :<|> ((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
               :> (UserAgent :> ToServantApi BlockfrostV0API))))
forall route.
BlockfrostAPI route
-> route
   :- ("api"
       :> ("v0"
           :> (BlockfrostAuth
               :> (UserAgent :> 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
                       -> AssetId
                       -> 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])))))))
       :<|> ((((Paged
                -> SortOrder
                -> ExceptT
                     BlockfrostError (ReaderT (ClientEnv, Project) IO) [ScriptHash])
               :<|> ((ScriptHash
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) Script)
                     :<|> (ScriptHash
                           -> Paged
                           -> SortOrder
                           -> ExceptT
                                BlockfrostError
                                (ReaderT (ClientEnv, Project) IO)
                                [ScriptRedeemer])))
              :<|> ((DatumHash
                     -> ExceptT
                          BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptDatum)
                    :<|> ((ScriptHash
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptJSON)
                          :<|> (ScriptHash
                                -> ExceptT
                                     BlockfrostError
                                     (ReaderT (ClientEnv, Project) IO)
                                     ScriptCBOR))))
             :<|> (((((TxHash
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                      :<|> (TxHash
                            -> ExceptT
                                 BlockfrostError
                                 (ReaderT (ClientEnv, Project) IO)
                                 TransactionUtxos))
                     :<|> ((TxHash
                            -> ExceptT
                                 BlockfrostError
                                 (ReaderT (ClientEnv, Project) IO)
                                 [TransactionRedeemer])
                           :<|> ((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
                        -> AssetId
                        -> 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])))))))
        :<|> ((((Paged
                 -> SortOrder
                 -> ExceptT
                      BlockfrostError (ReaderT (ClientEnv, Project) IO) [ScriptHash])
                :<|> ((ScriptHash
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) Script)
                      :<|> (ScriptHash
                            -> Paged
                            -> SortOrder
                            -> ExceptT
                                 BlockfrostError
                                 (ReaderT (ClientEnv, Project) IO)
                                 [ScriptRedeemer])))
               :<|> ((DatumHash
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptDatum)
                     :<|> ((ScriptHash
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptJSON)
                           :<|> (ScriptHash
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      ScriptCBOR))))
              :<|> (((((TxHash
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                       :<|> (TxHash
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  TransactionUtxos))
                      :<|> ((TxHash
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  [TransactionRedeemer])
                            :<|> ((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
                             -> AssetId
                             -> 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])))))))
             :<|> ((((Paged
                      -> SortOrder
                      -> ExceptT
                           BlockfrostError (ReaderT (ClientEnv, Project) IO) [ScriptHash])
                     :<|> ((ScriptHash
                            -> ExceptT
                                 BlockfrostError (ReaderT (ClientEnv, Project) IO) Script)
                           :<|> (ScriptHash
                                 -> Paged
                                 -> SortOrder
                                 -> ExceptT
                                      BlockfrostError
                                      (ReaderT (ClientEnv, Project) IO)
                                      [ScriptRedeemer])))
                    :<|> ((DatumHash
                           -> ExceptT
                                BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptDatum)
                          :<|> ((ScriptHash
                                 -> ExceptT
                                      BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptJSON)
                                :<|> (ScriptHash
                                      -> ExceptT
                                           BlockfrostError
                                           (ReaderT (ClientEnv, Project) IO)
                                           ScriptCBOR))))
                   :<|> (((((TxHash
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                            :<|> (TxHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       TransactionUtxos))
                           :<|> ((TxHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       [TransactionRedeemer])
                                 :<|> ((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
                         -> AssetId
                         -> 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])))))))
         :<|> ((((Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [ScriptHash])
                 :<|> ((ScriptHash
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) Script)
                       :<|> (ScriptHash
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  [ScriptRedeemer])))
                :<|> ((DatumHash
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptDatum)
                      :<|> ((ScriptHash
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptJSON)
                            :<|> (ScriptHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       ScriptCBOR))))
               :<|> (((((TxHash
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                        :<|> (TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   TransactionUtxos))
                       :<|> ((TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [TransactionRedeemer])
                             :<|> ((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
                          -> AssetId
                          -> 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])))))))
          :<|> ((((Paged
                   -> SortOrder
                   -> ExceptT
                        BlockfrostError (ReaderT (ClientEnv, Project) IO) [ScriptHash])
                  :<|> ((ScriptHash
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) Script)
                        :<|> (ScriptHash
                              -> Paged
                              -> SortOrder
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [ScriptRedeemer])))
                 :<|> ((DatumHash
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptDatum)
                       :<|> ((ScriptHash
                              -> ExceptT
                                   BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptJSON)
                             :<|> (ScriptHash
                                   -> ExceptT
                                        BlockfrostError
                                        (ReaderT (ClientEnv, Project) IO)
                                        ScriptCBOR))))
                :<|> (((((TxHash
                          -> ExceptT
                               BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                         :<|> (TxHash
                               -> ExceptT
                                    BlockfrostError
                                    (ReaderT (ClientEnv, Project) IO)
                                    TransactionUtxos))
                        :<|> ((TxHash
                               -> ExceptT
                                    BlockfrostError
                                    (ReaderT (ClientEnv, Project) IO)
                                    [TransactionRedeemer])
                              :<|> ((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
                         -> AssetId
                         -> 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])))))))
         :<|> ((((Paged
                  -> SortOrder
                  -> ExceptT
                       BlockfrostError (ReaderT (ClientEnv, Project) IO) [ScriptHash])
                 :<|> ((ScriptHash
                        -> ExceptT
                             BlockfrostError (ReaderT (ClientEnv, Project) IO) Script)
                       :<|> (ScriptHash
                             -> Paged
                             -> SortOrder
                             -> ExceptT
                                  BlockfrostError
                                  (ReaderT (ClientEnv, Project) IO)
                                  [ScriptRedeemer])))
                :<|> ((DatumHash
                       -> ExceptT
                            BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptDatum)
                      :<|> ((ScriptHash
                             -> ExceptT
                                  BlockfrostError (ReaderT (ClientEnv, Project) IO) ScriptJSON)
                            :<|> (ScriptHash
                                  -> ExceptT
                                       BlockfrostError
                                       (ReaderT (ClientEnv, Project) IO)
                                       ScriptCBOR))))
               :<|> (((((TxHash
                         -> ExceptT
                              BlockfrostError (ReaderT (ClientEnv, Project) IO) Transaction)
                        :<|> (TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   TransactionUtxos))
                       :<|> ((TxHash
                              -> ExceptT
                                   BlockfrostError
                                   (ReaderT (ClientEnv, Project) IO)
                                   [TransactionRedeemer])
                             :<|> ((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