{-|
Module      : Gargantext.API
Description : REST API declaration
Copyright   : (c) CNRS, 2017-Present
License     : AGPL + CECILL v3
Maintainer  : team@gargantext.org
Stability   : experimental
Portability : POSIX

Main (RESTful) API of the instance Gargantext.

The Garg-API is typed to derive the documentation, the mock and tests.

This API is indeed typed in order to be able to derive both the server
and the client sides.

The Garg-API-Monad enables:
  - Security (WIP)
  - Features (WIP)
  - Database connection (long term)
  - In Memory stack management (short term)
  - Logs (WIP)

Thanks to Yann Esposito for our discussions at the start and to Nicolas
Pouillard (who mainly made it).

-}

{-# LANGUAGE ScopedTypeVariables  #-}
{-# LANGUAGE TypeOperators        #-}
module Gargantext.API
      where

import Control.Exception (finally)
import Control.Lens
import Control.Monad.Reader (runReaderT)
import Data.List (lookup)
import Data.Text.Encoding (encodeUtf8)
import Data.Text.IO (putStrLn)
import Data.Validity
import GHC.Base (Applicative)
import GHC.Generics (Generic)
import Gargantext.API.Admin.Auth.Types (AuthContext)
import Gargantext.API.Admin.Settings (newEnv)
import Gargantext.API.Admin.Types (FireWall(..), PortNumber, cookieSettings, jwtSettings, settings)
import Gargantext.API.EKG
import Gargantext.API.Ngrams (saveNodeStory)
import Gargantext.API.Prelude
import Gargantext.API.Routes
import Gargantext.API.Server (server)
import Gargantext.Core.NodeStory
import Gargantext.Prelude hiding (putStrLn)
import Network.HTTP.Types hiding (Query)
import Network.Wai
import Network.Wai.Handler.Warp hiding (defaultSettings)
import Network.Wai.Middleware.Cors
import Network.Wai.Middleware.RequestLogger
import Paths_gargantext (getDataDir)
import Servant
import System.FilePath

data Mode = Dev | Mock | Prod
  deriving (Int -> Mode -> ShowS
[Mode] -> ShowS
Mode -> String
(Int -> Mode -> ShowS)
-> (Mode -> String) -> ([Mode] -> ShowS) -> Show Mode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mode] -> ShowS
$cshowList :: [Mode] -> ShowS
show :: Mode -> String
$cshow :: Mode -> String
showsPrec :: Int -> Mode -> ShowS
$cshowsPrec :: Int -> Mode -> ShowS
Show, ReadPrec [Mode]
ReadPrec Mode
Int -> ReadS Mode
ReadS [Mode]
(Int -> ReadS Mode)
-> ReadS [Mode] -> ReadPrec Mode -> ReadPrec [Mode] -> Read Mode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Mode]
$creadListPrec :: ReadPrec [Mode]
readPrec :: ReadPrec Mode
$creadPrec :: ReadPrec Mode
readList :: ReadS [Mode]
$creadList :: ReadS [Mode]
readsPrec :: Int -> ReadS Mode
$creadsPrec :: Int -> ReadS Mode
Read, (forall x. Mode -> Rep Mode x)
-> (forall x. Rep Mode x -> Mode) -> Generic Mode
forall x. Rep Mode x -> Mode
forall x. Mode -> Rep Mode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Mode x -> Mode
$cfrom :: forall x. Mode -> Rep Mode x
Generic)

-- | startGargantext takes as parameters port number and Ini file.
startGargantext :: Mode -> PortNumber -> FilePath -> IO ()
startGargantext :: Mode -> Int -> String -> IO ()
startGargantext Mode
mode Int
port String
file = do
  Env
env <- Int -> String -> IO Env
newEnv Int
port String
file
  Int -> IO ()
portRouteInfo Int
port
  Application
app <- Env -> IO Application
forall env. (Typeable env, EnvC env) => env -> IO Application
makeApp Env
env
  Middleware
mid <- Mode -> IO Middleware
makeDevMiddleware Mode
mode
  Int -> Application -> IO ()
run Int
port (Middleware
mid Application
app) IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
`finally` Env -> IO ()
forall env. HasNodeStorySaver env => env -> IO ()
stopGargantext Env
env

portRouteInfo :: PortNumber -> IO ()
portRouteInfo :: Int -> IO ()
portRouteInfo Int
port = do
  Text -> IO ()
putStrLn Text
"      ----Main Routes-----      "
  Text -> IO ()
putStrLn (Text -> IO ()) -> Text -> IO ()
forall a b. (a -> b) -> a -> b
$ Text
"http://localhost:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall a. ToHttpApiData a => a -> Text
toUrlPiece Int
port Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/index.html"
  Text -> IO ()
putStrLn (Text -> IO ()) -> Text -> IO ()
forall a b. (a -> b) -> a -> b
$ Text
"http://localhost:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall a. ToHttpApiData a => a -> Text
toUrlPiece Int
port Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/swagger-ui"

-- TODO clean this Monad condition (more generic) ?
stopGargantext :: HasNodeStorySaver env => env -> IO ()
stopGargantext :: env -> IO ()
stopGargantext env
env = do
  Text -> IO ()
putStrLn Text
"----- Stopping gargantext -----"
  ReaderT env IO () -> env -> IO ()
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT env IO ()
forall env (m :: * -> *).
(MonadReader env m, MonadBase IO m, HasNodeStorySaver env) =>
m ()
saveNodeStory env
env

{-
startGargantextMock :: PortNumber -> IO ()
startGargantextMock port = do
  portRouteInfo port
  application <- makeMockApp . MockEnv $ FireWall False
  run port application
-}

----------------------------------------------------------------------

fireWall :: Applicative f => Request -> FireWall -> f Bool
fireWall :: Request -> FireWall -> f Bool
fireWall Request
req FireWall
fw = do
    let origin :: Maybe ByteString
origin = HeaderName -> [(HeaderName, ByteString)] -> Maybe ByteString
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup HeaderName
"Origin" (Request -> [(HeaderName, ByteString)]
requestHeaders Request
req)
    let host :: Maybe ByteString
host   = HeaderName -> [(HeaderName, ByteString)] -> Maybe ByteString
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup HeaderName
"Host"   (Request -> [(HeaderName, ByteString)]
requestHeaders Request
req)

    if  Maybe ByteString
origin Maybe ByteString -> Maybe ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
encodeUtf8 Text
"http://localhost:8008")
       Bool -> Bool -> Bool
&& Maybe ByteString
host Maybe ByteString -> Maybe ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
encodeUtf8 Text
"localhost:3000")
       Bool -> Bool -> Bool
|| (Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ FireWall -> Bool
unFireWall FireWall
fw)

       then Bool -> f Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
       else Bool -> f Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False

{-
-- makeMockApp :: Env -> IO (Warp.Settings, Application)
makeMockApp :: MockEnv -> IO Application
makeMockApp env = do
    let serverApp = appMock

    -- logWare <- mkRequestLogger def { destination = RequestLogger.Logger $ env^.logger }
    --logWare <- mkRequestLogger def { destination = RequestLogger.Logger "/tmp/logs.txt" }
    let checkOriginAndHost app req resp = do
            blocking <- fireWall req (env ^. menv_firewall)
            case blocking  of
                True  -> app req resp
                False -> resp ( responseLBS status401 [] 
                              "Invalid Origin or Host header")
        
    let corsMiddleware = cors $ \_ -> Just CorsResourcePolicy
--          { corsOrigins        = Just ([env^.settings.allowedOrigin], False)
            { corsOrigins        = Nothing --  == /*
            , corsMethods        = [ methodGet   , methodPost   , methodPut
                                   , methodDelete, methodOptions, methodHead]
            , corsRequestHeaders = ["authorization", "content-type"]
            , corsExposedHeaders = Nothing
            , corsMaxAge         = Just ( 60*60*24 ) -- one day
            , corsVaryOrigin     = False
            , corsRequireOrigin  = False
            , corsIgnoreFailures = False
            }

    --let warpS = Warp.setPort (8008 :: Int)   -- (env^.settings.appPort)
    --          $ Warp.defaultSettings
    
    --pure (warpS, logWare $ checkOriginAndHost $ corsMiddleware $ serverApp)
    pure $ logStdoutDev $ checkOriginAndHost $ corsMiddleware $ serverApp
-}


makeDevMiddleware :: Mode -> IO Middleware
makeDevMiddleware :: Mode -> IO Middleware
makeDevMiddleware Mode
mode = do
-- logWare <- mkRequestLogger def { destination = RequestLogger.Logger $ env^.logger }
-- logWare <- mkRequestLogger def { destination = RequestLogger.Logger "/tmp/logs.txt" }
--    let checkOriginAndHost app req resp = do
--            blocking <- fireWall req (env ^. menv_firewall)
--            case blocking  of
--                True  -> app req resp
--                False -> resp ( responseLBS status401 [] 
--                              "Invalid Origin or Host header")
--
    let corsMiddleware :: Middleware
corsMiddleware = (Request -> Maybe CorsResourcePolicy) -> Middleware
cors ((Request -> Maybe CorsResourcePolicy) -> Middleware)
-> (Request -> Maybe CorsResourcePolicy) -> Middleware
forall a b. (a -> b) -> a -> b
$ \Request
_ -> CorsResourcePolicy -> Maybe CorsResourcePolicy
forall a. a -> Maybe a
Just CorsResourcePolicy :: Maybe ([ByteString], Bool)
-> [ByteString]
-> [HeaderName]
-> Maybe [HeaderName]
-> Maybe Int
-> Bool
-> Bool
-> Bool
-> CorsResourcePolicy
CorsResourcePolicy
--          { corsOrigins        = Just ([env^.settings.allowedOrigin], False)
            { corsOrigins :: Maybe ([ByteString], Bool)
corsOrigins        = Maybe ([ByteString], Bool)
forall a. Maybe a
Nothing --  == /*
            , corsMethods :: [ByteString]
corsMethods        = [ ByteString
methodGet   , ByteString
methodPost   , ByteString
methodPut
                                   , ByteString
methodDelete, ByteString
methodOptions, ByteString
methodHead]
            , corsRequestHeaders :: [HeaderName]
corsRequestHeaders = [HeaderName
"authorization", HeaderName
"content-type"]
            , corsExposedHeaders :: Maybe [HeaderName]
corsExposedHeaders = Maybe [HeaderName]
forall a. Maybe a
Nothing
            , corsMaxAge :: Maybe Int
corsMaxAge         = Int -> Maybe Int
forall a. a -> Maybe a
Just ( Int
60Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
60Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
24 ) -- one day
            , corsVaryOrigin :: Bool
corsVaryOrigin     = Bool
False
            , corsRequireOrigin :: Bool
corsRequireOrigin  = Bool
False
            , corsIgnoreFailures :: Bool
corsIgnoreFailures = Bool
False
            }

    --let warpS = Warp.setPort (8008 :: Int)   -- (env^.settings.appPort)
    --          $ Warp.defaultSettings

    --pure (warpS, logWare . checkOriginAndHost . corsMiddleware)
    case Mode
mode of
      Mode
Prod -> Middleware -> IO Middleware
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Middleware -> IO Middleware) -> Middleware -> IO Middleware
forall a b. (a -> b) -> a -> b
$ Middleware
logStdout Middleware -> Middleware -> Middleware
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Middleware
corsMiddleware
      Mode
_    -> Middleware -> IO Middleware
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Middleware -> IO Middleware) -> Middleware -> IO Middleware
forall a b. (a -> b) -> a -> b
$ Middleware
logStdoutDev Middleware -> Middleware -> Middleware
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Middleware
corsMiddleware

---------------------------------------------------------------------
-- | API Global
---------------------------------------------------------------------

---------------------------


-- TODO-SECURITY admin only: withAdmin
-- Question: How do we mark admins?
{-
serverGargAdminAPI :: GargServer GargAdminAPI
serverGargAdminAPI =  roots
                 :<|> nodesAPI
-}

---------------------------------------------------------------------
--gargMock :: Server GargAPI
--gargMock = mock apiGarg Proxy
---------------------------------------------------------------------

makeApp :: (Typeable env, EnvC env) => env -> IO Application
makeApp :: env -> IO Application
makeApp env
env = do
  (Handler Value
 :<|> (Handler
         (SwaggerUiHtml "swagger-ui" ("swagger.json" :> Get '[JSON] Value))
       :<|> (Handler
               (SwaggerUiHtml "swagger-ui" ("swagger.json" :> Get '[JSON] Value))
             :<|> Tagged Handler Application)))
:<|> (((AuthRequest -> Handler AuthResponse)
       :<|> (Handler Text
             :<|> ((AuthResult AuthenticatedUser
                    -> ((Handler [Node HyperdataUser] :<|> Handler Int)
                        :<|> ([NodeId] -> Handler Int))
                       :<|> ((NodeId
                              -> Handler
                                   (NodePoly
                                      NodeId
                                      (Maybe Text)
                                      Int
                                      Int
                                      (Maybe NodeId)
                                      Text
                                      UTCTime
                                      HyperdataAny)
                                 :<|> ((RenameNode -> Handler [Int])
                                       :<|> ((PostNode -> Handler [NodeId])
                                             :<|> ((Handler (JobStatus 'Safe JobLog)
                                                    :<|> ((JobInput Maybe PostNode
                                                           -> Handler (JobStatus 'Safe JobLog))
                                                          :<|> (ID 'Unsafe "job"
                                                                -> (Maybe Limit
                                                                    -> Maybe Offset
                                                                    -> Handler
                                                                         (JobStatus 'Safe JobLog))
                                                                   :<|> ((Maybe Limit
                                                                          -> Maybe Offset
                                                                          -> Handler
                                                                               (JobStatus
                                                                                  'Safe JobLog))
                                                                         :<|> Handler
                                                                                (JobOutput
                                                                                   JobLog)))))
                                                   :<|> ((Handler (JobStatus 'Safe JobLog)
                                                          :<|> ((JobInput Maybe FrameCalcUpload
                                                                 -> Handler
                                                                      (JobStatus 'Safe JobLog))
                                                                :<|> (ID 'Unsafe "job"
                                                                      -> (Maybe Limit
                                                                          -> Maybe Offset
                                                                          -> Handler
                                                                               (JobStatus
                                                                                  'Safe JobLog))
                                                                         :<|> ((Maybe Limit
                                                                                -> Maybe Offset
                                                                                -> Handler
                                                                                     (JobStatus
                                                                                        'Safe
                                                                                        JobLog))
                                                                               :<|> Handler
                                                                                      (JobOutput
                                                                                         JobLog)))))
                                                         :<|> ((HyperdataAny -> Handler Int)
                                                               :<|> ((Handler
                                                                        (JobStatus 'Safe JobLog)
                                                                      :<|> ((JobInput
                                                                               Maybe
                                                                               UpdateNodeParams
                                                                             -> Handler
                                                                                  (JobStatus
                                                                                     'Safe JobLog))
                                                                            :<|> (ID 'Unsafe "job"
                                                                                  -> (Maybe Limit
                                                                                      -> Maybe
                                                                                           Offset
                                                                                      -> Handler
                                                                                           (JobStatus
                                                                                              'Safe
                                                                                              JobLog))
                                                                                     :<|> ((Maybe
                                                                                              Limit
                                                                                            -> Maybe
                                                                                                 Offset
                                                                                            -> Handler
                                                                                                 (JobStatus
                                                                                                    'Safe
                                                                                                    JobLog))
                                                                                           :<|> Handler
                                                                                                  (JobOutput
                                                                                                     JobLog)))))
                                                                     :<|> (Handler Int
                                                                           :<|> ((Maybe NodeType
                                                                                  -> Maybe Int
                                                                                  -> Maybe Int
                                                                                  -> Handler
                                                                                       (TableResult
                                                                                          (NodePoly
                                                                                             NodeId
                                                                                             (Maybe
                                                                                                Text)
                                                                                             Int
                                                                                             Int
                                                                                             (Maybe
                                                                                                NodeId)
                                                                                             Text
                                                                                             UTCTime
                                                                                             HyperdataAny)))
                                                                                 :<|> (((Maybe
                                                                                           TabType
                                                                                         -> Maybe
                                                                                              NodeId
                                                                                         -> Maybe
                                                                                              Int
                                                                                         -> Maybe
                                                                                              Int
                                                                                         -> Maybe
                                                                                              OrderBy
                                                                                         -> Maybe
                                                                                              Text
                                                                                         -> Handler
                                                                                              (HashedResponse
                                                                                                 FacetTableResult))
                                                                                        :<|> ((TableQuery
                                                                                               -> Handler
                                                                                                    FacetTableResult)
                                                                                              :<|> (Maybe
                                                                                                      TabType
                                                                                                    -> Handler
                                                                                                         Text)))
                                                                                       :<|> (((TabType
                                                                                               -> NodeId
                                                                                               -> Int
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    ListType
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    OrderBy
                                                                                               -> Maybe
                                                                                                    Text
                                                                                               -> Handler
                                                                                                    (VersionedWithCount
                                                                                                       NgramsTable))
                                                                                              :<|> ((TabType
                                                                                                     -> NodeId
                                                                                                     -> Versioned
                                                                                                          NgramsTablePatch
                                                                                                     -> Handler
                                                                                                          (Versioned
                                                                                                             NgramsTablePatch))
                                                                                                    :<|> ((TabType
                                                                                                           -> NodeId
                                                                                                           -> Handler
                                                                                                                Int)
                                                                                                          :<|> ((TabType
                                                                                                                 -> NodeId
                                                                                                                 -> Handler
                                                                                                                      Int)
                                                                                                                :<|> (Handler
                                                                                                                        (JobStatus
                                                                                                                           'Safe
                                                                                                                           JobLog)
                                                                                                                      :<|> ((JobInput
                                                                                                                               Maybe
                                                                                                                               UpdateTableNgramsCharts
                                                                                                                             -> Handler
                                                                                                                                  (JobStatus
                                                                                                                                     'Safe
                                                                                                                                     JobLog))
                                                                                                                            :<|> (ID
                                                                                                                                    'Unsafe
                                                                                                                                    "job"
                                                                                                                                  -> (Maybe
                                                                                                                                        Limit
                                                                                                                                      -> Maybe
                                                                                                                                           Offset
                                                                                                                                      -> Handler
                                                                                                                                           (JobStatus
                                                                                                                                              'Safe
                                                                                                                                              JobLog))
                                                                                                                                     :<|> ((Maybe
                                                                                                                                              Limit
                                                                                                                                            -> Maybe
                                                                                                                                                 Offset
                                                                                                                                            -> Handler
                                                                                                                                                 (JobStatus
                                                                                                                                                    'Safe
                                                                                                                                                    JobLog))
                                                                                                                                           :<|> Handler
                                                                                                                                                  (JobOutput
                                                                                                                                                     JobLog)))))))))
                                                                                             :<|> ((NodesToCategory
                                                                                                    -> Handler
                                                                                                         [Int])
                                                                                                   :<|> ((NodesToScore
                                                                                                          -> Handler
                                                                                                               [Int])
                                                                                                         :<|> ((SearchQuery
                                                                                                                -> Maybe
                                                                                                                     Int
                                                                                                                -> Maybe
                                                                                                                     Int
                                                                                                                -> Maybe
                                                                                                                     OrderBy
                                                                                                                -> Handler
                                                                                                                     SearchResult)
                                                                                                               :<|> ((ShareNodeParams
                                                                                                                      -> Handler
                                                                                                                           Int)
                                                                                                                     :<|> ((NodeId
                                                                                                                            -> Maybe
                                                                                                                                 NodeId
                                                                                                                            -> Handler
                                                                                                                                 Int)
                                                                                                                           :<|> (Handler
                                                                                                                                   [NodeId]
                                                                                                                                 :<|> ((Maybe
                                                                                                                                          TabType
                                                                                                                                        -> Maybe
                                                                                                                                             Int
                                                                                                                                        -> Maybe
                                                                                                                                             Int
                                                                                                                                        -> Maybe
                                                                                                                                             OrderBy
                                                                                                                                        -> Handler
                                                                                                                                             [FacetDoc])
                                                                                                                                       :<|> (((Maybe
                                                                                                                                                 NodeId
                                                                                                                                               -> TabType
                                                                                                                                               -> Maybe
                                                                                                                                                    Int
                                                                                                                                               -> Handler
                                                                                                                                                    (HashedResponse
                                                                                                                                                       Metrics))
                                                                                                                                              :<|> ((Maybe
                                                                                                                                                       NodeId
                                                                                                                                                     -> TabType
                                                                                                                                                     -> Maybe
                                                                                                                                                          Int
                                                                                                                                                     -> Handler
                                                                                                                                                          ())
                                                                                                                                                    :<|> (Maybe
                                                                                                                                                            NodeId
                                                                                                                                                          -> TabType
                                                                                                                                                          -> Handler
                                                                                                                                                               Text)))
                                                                                                                                             :<|> (((Maybe
                                                                                                                                                       UTCTime
                                                                                                                                                     -> Maybe
                                                                                                                                                          UTCTime
                                                                                                                                                     -> Maybe
                                                                                                                                                          NodeId
                                                                                                                                                     -> TabType
                                                                                                                                                     -> Handler
                                                                                                                                                          (HashedResponse
                                                                                                                                                             (ChartMetrics
                                                                                                                                                                Histo)))
                                                                                                                                                    :<|> ((Maybe
                                                                                                                                                             NodeId
                                                                                                                                                           -> TabType
                                                                                                                                                           -> Maybe
                                                                                                                                                                Int
                                                                                                                                                           -> Handler
                                                                                                                                                                ())
                                                                                                                                                          :<|> (Maybe
                                                                                                                                                                  NodeId
                                                                                                                                                                -> TabType
                                                                                                                                                                -> Handler
                                                                                                                                                                     Text)))
                                                                                                                                                   :<|> (((Maybe
                                                                                                                                                             UTCTime
                                                                                                                                                           -> Maybe
                                                                                                                                                                UTCTime
                                                                                                                                                           -> Maybe
                                                                                                                                                                NodeId
                                                                                                                                                           -> TabType
                                                                                                                                                           -> Handler
                                                                                                                                                                (HashedResponse
                                                                                                                                                                   (ChartMetrics
                                                                                                                                                                      Histo)))
                                                                                                                                                          :<|> ((Maybe
                                                                                                                                                                   NodeId
                                                                                                                                                                 -> TabType
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      Int
                                                                                                                                                                 -> Handler
                                                                                                                                                                      ())
                                                                                                                                                                :<|> (Maybe
                                                                                                                                                                        NodeId
                                                                                                                                                                      -> TabType
                                                                                                                                                                      -> Handler
                                                                                                                                                                           Text)))
                                                                                                                                                         :<|> (((Maybe
                                                                                                                                                                   UTCTime
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      UTCTime
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      NodeId
                                                                                                                                                                 -> TabType
                                                                                                                                                                 -> ListType
                                                                                                                                                                 -> Handler
                                                                                                                                                                      (HashedResponse
                                                                                                                                                                         (ChartMetrics
                                                                                                                                                                            (Vector
                                                                                                                                                                               NgramsTree))))
                                                                                                                                                                :<|> ((Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                       -> TabType
                                                                                                                                                                       -> ListType
                                                                                                                                                                       -> Handler
                                                                                                                                                                            ())
                                                                                                                                                                      :<|> (Maybe
                                                                                                                                                                              NodeId
                                                                                                                                                                            -> TabType
                                                                                                                                                                            -> ListType
                                                                                                                                                                            -> Handler
                                                                                                                                                                                 Text)))
                                                                                                                                                               :<|> (((Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            Int
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            Int
                                                                                                                                                                       -> Handler
                                                                                                                                                                            SVG)
                                                                                                                                                                      :<|> (Maybe
                                                                                                                                                                              NodeId
                                                                                                                                                                            -> Handler
                                                                                                                                                                                 NodeId))
                                                                                                                                                                     :<|> ((NodeId
                                                                                                                                                                            -> Handler
                                                                                                                                                                                 [Int])
                                                                                                                                                                           :<|> ((NodeId
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       Int)
                                                                                                                                                                                 :<|> (Handler
                                                                                                                                                                                         (Headers
                                                                                                                                                                                            '[Header
                                                                                                                                                                                                "Content-Type"
                                                                                                                                                                                                Text]
                                                                                                                                                                                            BSResponse)
                                                                                                                                                                                       :<|> ((Handler
                                                                                                                                                                                                (JobStatus
                                                                                                                                                                                                   'Safe
                                                                                                                                                                                                   JobLog)
                                                                                                                                                                                              :<|> ((JobInput
                                                                                                                                                                                                       Maybe
                                                                                                                                                                                                       NewWithFile
                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                             JobLog))
                                                                                                                                                                                                    :<|> (ID
                                                                                                                                                                                                            'Unsafe
                                                                                                                                                                                                            "job"
                                                                                                                                                                                                          -> (Maybe
                                                                                                                                                                                                                Limit
                                                                                                                                                                                                              -> Maybe
                                                                                                                                                                                                                   Offset
                                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                                   (JobStatus
                                                                                                                                                                                                                      'Safe
                                                                                                                                                                                                                      JobLog))
                                                                                                                                                                                                             :<|> ((Maybe
                                                                                                                                                                                                                      Limit
                                                                                                                                                                                                                    -> Maybe
                                                                                                                                                                                                                         Offset
                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                   :<|> Handler
                                                                                                                                                                                                                          (JobOutput
                                                                                                                                                                                                                             JobLog)))))
                                                                                                                                                                                             :<|> ((Handler
                                                                                                                                                                                                      (JobStatus
                                                                                                                                                                                                         'Safe
                                                                                                                                                                                                         JobLog)
                                                                                                                                                                                                    :<|> ((JobInput
                                                                                                                                                                                                             Maybe
                                                                                                                                                                                                             Params
                                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                                (JobStatus
                                                                                                                                                                                                                   'Safe
                                                                                                                                                                                                                   JobLog))
                                                                                                                                                                                                          :<|> (ID
                                                                                                                                                                                                                  'Unsafe
                                                                                                                                                                                                                  "job"
                                                                                                                                                                                                                -> (Maybe
                                                                                                                                                                                                                      Limit
                                                                                                                                                                                                                    -> Maybe
                                                                                                                                                                                                                         Offset
                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                   :<|> ((Maybe
                                                                                                                                                                                                                            Limit
                                                                                                                                                                                                                          -> Maybe
                                                                                                                                                                                                                               Offset
                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                         :<|> Handler
                                                                                                                                                                                                                                (JobOutput
                                                                                                                                                                                                                                   JobLog)))))
                                                                                                                                                                                                   :<|> (Handler
                                                                                                                                                                                                           (JobStatus
                                                                                                                                                                                                              'Safe
                                                                                                                                                                                                              JobLog)
                                                                                                                                                                                                         :<|> ((JobInput
                                                                                                                                                                                                                  Maybe
                                                                                                                                                                                                                  DocumentUpload
                                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                                     (JobStatus
                                                                                                                                                                                                                        'Safe
                                                                                                                                                                                                                        JobLog))
                                                                                                                                                                                                               :<|> (ID
                                                                                                                                                                                                                       'Unsafe
                                                                                                                                                                                                                       "job"
                                                                                                                                                                                                                     -> (Maybe
                                                                                                                                                                                                                           Limit
                                                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                                                              Offset
                                                                                                                                                                                                                         -> Handler
                                                                                                                                                                                                                              (JobStatus
                                                                                                                                                                                                                                 'Safe
                                                                                                                                                                                                                                 JobLog))
                                                                                                                                                                                                                        :<|> ((Maybe
                                                                                                                                                                                                                                 Limit
                                                                                                                                                                                                                               -> Maybe
                                                                                                                                                                                                                                    Offset
                                                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                                                       JobLog))
                                                                                                                                                                                                                              :<|> Handler
                                                                                                                                                                                                                                     (JobOutput
                                                                                                                                                                                                                                        JobLog)))))))))))))))))))))))))))))))))
                             :<|> ((NodeId
                                    -> Handler
                                         (NodePoly
                                            NodeId
                                            (Maybe Text)
                                            Int
                                            Int
                                            (Maybe NodeId)
                                            Text
                                            UTCTime
                                            HyperdataCorpus)
                                       :<|> ((RenameNode -> Handler [Int])
                                             :<|> ((PostNode -> Handler [NodeId])
                                                   :<|> ((Handler (JobStatus 'Safe JobLog)
                                                          :<|> ((JobInput Maybe PostNode
                                                                 -> Handler
                                                                      (JobStatus 'Safe JobLog))
                                                                :<|> (ID 'Unsafe "job"
                                                                      -> (Maybe Limit
                                                                          -> Maybe Offset
                                                                          -> Handler
                                                                               (JobStatus
                                                                                  'Safe JobLog))
                                                                         :<|> ((Maybe Limit
                                                                                -> Maybe Offset
                                                                                -> Handler
                                                                                     (JobStatus
                                                                                        'Safe
                                                                                        JobLog))
                                                                               :<|> Handler
                                                                                      (JobOutput
                                                                                         JobLog)))))
                                                         :<|> ((Handler (JobStatus 'Safe JobLog)
                                                                :<|> ((JobInput
                                                                         Maybe FrameCalcUpload
                                                                       -> Handler
                                                                            (JobStatus
                                                                               'Safe JobLog))
                                                                      :<|> (ID 'Unsafe "job"
                                                                            -> (Maybe Limit
                                                                                -> Maybe Offset
                                                                                -> Handler
                                                                                     (JobStatus
                                                                                        'Safe
                                                                                        JobLog))
                                                                               :<|> ((Maybe Limit
                                                                                      -> Maybe
                                                                                           Offset
                                                                                      -> Handler
                                                                                           (JobStatus
                                                                                              'Safe
                                                                                              JobLog))
                                                                                     :<|> Handler
                                                                                            (JobOutput
                                                                                               JobLog)))))
                                                               :<|> ((HyperdataCorpus
                                                                      -> Handler Int)
                                                                     :<|> ((Handler
                                                                              (JobStatus
                                                                                 'Safe JobLog)
                                                                            :<|> ((JobInput
                                                                                     Maybe
                                                                                     UpdateNodeParams
                                                                                   -> Handler
                                                                                        (JobStatus
                                                                                           'Safe
                                                                                           JobLog))
                                                                                  :<|> (ID
                                                                                          'Unsafe
                                                                                          "job"
                                                                                        -> (Maybe
                                                                                              Limit
                                                                                            -> Maybe
                                                                                                 Offset
                                                                                            -> Handler
                                                                                                 (JobStatus
                                                                                                    'Safe
                                                                                                    JobLog))
                                                                                           :<|> ((Maybe
                                                                                                    Limit
                                                                                                  -> Maybe
                                                                                                       Offset
                                                                                                  -> Handler
                                                                                                       (JobStatus
                                                                                                          'Safe
                                                                                                          JobLog))
                                                                                                 :<|> Handler
                                                                                                        (JobOutput
                                                                                                           JobLog)))))
                                                                           :<|> (Handler Int
                                                                                 :<|> ((Maybe
                                                                                          NodeType
                                                                                        -> Maybe Int
                                                                                        -> Maybe Int
                                                                                        -> Handler
                                                                                             (TableResult
                                                                                                (NodePoly
                                                                                                   NodeId
                                                                                                   (Maybe
                                                                                                      Text)
                                                                                                   Int
                                                                                                   Int
                                                                                                   (Maybe
                                                                                                      NodeId)
                                                                                                   Text
                                                                                                   UTCTime
                                                                                                   HyperdataCorpus)))
                                                                                       :<|> (((Maybe
                                                                                                 TabType
                                                                                               -> Maybe
                                                                                                    NodeId
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    OrderBy
                                                                                               -> Maybe
                                                                                                    Text
                                                                                               -> Handler
                                                                                                    (HashedResponse
                                                                                                       FacetTableResult))
                                                                                              :<|> ((TableQuery
                                                                                                     -> Handler
                                                                                                          FacetTableResult)
                                                                                                    :<|> (Maybe
                                                                                                            TabType
                                                                                                          -> Handler
                                                                                                               Text)))
                                                                                             :<|> (((TabType
                                                                                                     -> NodeId
                                                                                                     -> Int
                                                                                                     -> Maybe
                                                                                                          Int
                                                                                                     -> Maybe
                                                                                                          ListType
                                                                                                     -> Maybe
                                                                                                          Int
                                                                                                     -> Maybe
                                                                                                          Int
                                                                                                     -> Maybe
                                                                                                          OrderBy
                                                                                                     -> Maybe
                                                                                                          Text
                                                                                                     -> Handler
                                                                                                          (VersionedWithCount
                                                                                                             NgramsTable))
                                                                                                    :<|> ((TabType
                                                                                                           -> NodeId
                                                                                                           -> Versioned
                                                                                                                NgramsTablePatch
                                                                                                           -> Handler
                                                                                                                (Versioned
                                                                                                                   NgramsTablePatch))
                                                                                                          :<|> ((TabType
                                                                                                                 -> NodeId
                                                                                                                 -> Handler
                                                                                                                      Int)
                                                                                                                :<|> ((TabType
                                                                                                                       -> NodeId
                                                                                                                       -> Handler
                                                                                                                            Int)
                                                                                                                      :<|> (Handler
                                                                                                                              (JobStatus
                                                                                                                                 'Safe
                                                                                                                                 JobLog)
                                                                                                                            :<|> ((JobInput
                                                                                                                                     Maybe
                                                                                                                                     UpdateTableNgramsCharts
                                                                                                                                   -> Handler
                                                                                                                                        (JobStatus
                                                                                                                                           'Safe
                                                                                                                                           JobLog))
                                                                                                                                  :<|> (ID
                                                                                                                                          'Unsafe
                                                                                                                                          "job"
                                                                                                                                        -> (Maybe
                                                                                                                                              Limit
                                                                                                                                            -> Maybe
                                                                                                                                                 Offset
                                                                                                                                            -> Handler
                                                                                                                                                 (JobStatus
                                                                                                                                                    'Safe
                                                                                                                                                    JobLog))
                                                                                                                                           :<|> ((Maybe
                                                                                                                                                    Limit
                                                                                                                                                  -> Maybe
                                                                                                                                                       Offset
                                                                                                                                                  -> Handler
                                                                                                                                                       (JobStatus
                                                                                                                                                          'Safe
                                                                                                                                                          JobLog))
                                                                                                                                                 :<|> Handler
                                                                                                                                                        (JobOutput
                                                                                                                                                           JobLog)))))))))
                                                                                                   :<|> ((NodesToCategory
                                                                                                          -> Handler
                                                                                                               [Int])
                                                                                                         :<|> ((NodesToScore
                                                                                                                -> Handler
                                                                                                                     [Int])
                                                                                                               :<|> ((SearchQuery
                                                                                                                      -> Maybe
                                                                                                                           Int
                                                                                                                      -> Maybe
                                                                                                                           Int
                                                                                                                      -> Maybe
                                                                                                                           OrderBy
                                                                                                                      -> Handler
                                                                                                                           SearchResult)
                                                                                                                     :<|> ((ShareNodeParams
                                                                                                                            -> Handler
                                                                                                                                 Int)
                                                                                                                           :<|> ((NodeId
                                                                                                                                  -> Maybe
                                                                                                                                       NodeId
                                                                                                                                  -> Handler
                                                                                                                                       Int)
                                                                                                                                 :<|> (Handler
                                                                                                                                         [NodeId]
                                                                                                                                       :<|> ((Maybe
                                                                                                                                                TabType
                                                                                                                                              -> Maybe
                                                                                                                                                   Int
                                                                                                                                              -> Maybe
                                                                                                                                                   Int
                                                                                                                                              -> Maybe
                                                                                                                                                   OrderBy
                                                                                                                                              -> Handler
                                                                                                                                                   [FacetDoc])
                                                                                                                                             :<|> (((Maybe
                                                                                                                                                       NodeId
                                                                                                                                                     -> TabType
                                                                                                                                                     -> Maybe
                                                                                                                                                          Int
                                                                                                                                                     -> Handler
                                                                                                                                                          (HashedResponse
                                                                                                                                                             Metrics))
                                                                                                                                                    :<|> ((Maybe
                                                                                                                                                             NodeId
                                                                                                                                                           -> TabType
                                                                                                                                                           -> Maybe
                                                                                                                                                                Int
                                                                                                                                                           -> Handler
                                                                                                                                                                ())
                                                                                                                                                          :<|> (Maybe
                                                                                                                                                                  NodeId
                                                                                                                                                                -> TabType
                                                                                                                                                                -> Handler
                                                                                                                                                                     Text)))
                                                                                                                                                   :<|> (((Maybe
                                                                                                                                                             UTCTime
                                                                                                                                                           -> Maybe
                                                                                                                                                                UTCTime
                                                                                                                                                           -> Maybe
                                                                                                                                                                NodeId
                                                                                                                                                           -> TabType
                                                                                                                                                           -> Handler
                                                                                                                                                                (HashedResponse
                                                                                                                                                                   (ChartMetrics
                                                                                                                                                                      Histo)))
                                                                                                                                                          :<|> ((Maybe
                                                                                                                                                                   NodeId
                                                                                                                                                                 -> TabType
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      Int
                                                                                                                                                                 -> Handler
                                                                                                                                                                      ())
                                                                                                                                                                :<|> (Maybe
                                                                                                                                                                        NodeId
                                                                                                                                                                      -> TabType
                                                                                                                                                                      -> Handler
                                                                                                                                                                           Text)))
                                                                                                                                                         :<|> (((Maybe
                                                                                                                                                                   UTCTime
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      UTCTime
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      NodeId
                                                                                                                                                                 -> TabType
                                                                                                                                                                 -> Handler
                                                                                                                                                                      (HashedResponse
                                                                                                                                                                         (ChartMetrics
                                                                                                                                                                            Histo)))
                                                                                                                                                                :<|> ((Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                       -> TabType
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            Int
                                                                                                                                                                       -> Handler
                                                                                                                                                                            ())
                                                                                                                                                                      :<|> (Maybe
                                                                                                                                                                              NodeId
                                                                                                                                                                            -> TabType
                                                                                                                                                                            -> Handler
                                                                                                                                                                                 Text)))
                                                                                                                                                               :<|> (((Maybe
                                                                                                                                                                         UTCTime
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            UTCTime
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            NodeId
                                                                                                                                                                       -> TabType
                                                                                                                                                                       -> ListType
                                                                                                                                                                       -> Handler
                                                                                                                                                                            (HashedResponse
                                                                                                                                                                               (ChartMetrics
                                                                                                                                                                                  (Vector
                                                                                                                                                                                     NgramsTree))))
                                                                                                                                                                      :<|> ((Maybe
                                                                                                                                                                               NodeId
                                                                                                                                                                             -> TabType
                                                                                                                                                                             -> ListType
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  ())
                                                                                                                                                                            :<|> (Maybe
                                                                                                                                                                                    NodeId
                                                                                                                                                                                  -> TabType
                                                                                                                                                                                  -> ListType
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       Text)))
                                                                                                                                                                     :<|> (((Maybe
                                                                                                                                                                               NodeId
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  Int
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  Int
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  SVG)
                                                                                                                                                                            :<|> (Maybe
                                                                                                                                                                                    NodeId
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       NodeId))
                                                                                                                                                                           :<|> ((NodeId
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       [Int])
                                                                                                                                                                                 :<|> ((NodeId
                                                                                                                                                                                        -> Handler
                                                                                                                                                                                             Int)
                                                                                                                                                                                       :<|> (Handler
                                                                                                                                                                                               (Headers
                                                                                                                                                                                                  '[Header
                                                                                                                                                                                                      "Content-Type"
                                                                                                                                                                                                      Text]
                                                                                                                                                                                                  BSResponse)
                                                                                                                                                                                             :<|> ((Handler
                                                                                                                                                                                                      (JobStatus
                                                                                                                                                                                                         'Safe
                                                                                                                                                                                                         JobLog)
                                                                                                                                                                                                    :<|> ((JobInput
                                                                                                                                                                                                             Maybe
                                                                                                                                                                                                             NewWithFile
                                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                                (JobStatus
                                                                                                                                                                                                                   'Safe
                                                                                                                                                                                                                   JobLog))
                                                                                                                                                                                                          :<|> (ID
                                                                                                                                                                                                                  'Unsafe
                                                                                                                                                                                                                  "job"
                                                                                                                                                                                                                -> (Maybe
                                                                                                                                                                                                                      Limit
                                                                                                                                                                                                                    -> Maybe
                                                                                                                                                                                                                         Offset
                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                   :<|> ((Maybe
                                                                                                                                                                                                                            Limit
                                                                                                                                                                                                                          -> Maybe
                                                                                                                                                                                                                               Offset
                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                         :<|> Handler
                                                                                                                                                                                                                                (JobOutput
                                                                                                                                                                                                                                   JobLog)))))
                                                                                                                                                                                                   :<|> ((Handler
                                                                                                                                                                                                            (JobStatus
                                                                                                                                                                                                               'Safe
                                                                                                                                                                                                               JobLog)
                                                                                                                                                                                                          :<|> ((JobInput
                                                                                                                                                                                                                   Maybe
                                                                                                                                                                                                                   Params
                                                                                                                                                                                                                 -> Handler
                                                                                                                                                                                                                      (JobStatus
                                                                                                                                                                                                                         'Safe
                                                                                                                                                                                                                         JobLog))
                                                                                                                                                                                                                :<|> (ID
                                                                                                                                                                                                                        'Unsafe
                                                                                                                                                                                                                        "job"
                                                                                                                                                                                                                      -> (Maybe
                                                                                                                                                                                                                            Limit
                                                                                                                                                                                                                          -> Maybe
                                                                                                                                                                                                                               Offset
                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                         :<|> ((Maybe
                                                                                                                                                                                                                                  Limit
                                                                                                                                                                                                                                -> Maybe
                                                                                                                                                                                                                                     Offset
                                                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                                                     (JobStatus
                                                                                                                                                                                                                                        'Safe
                                                                                                                                                                                                                                        JobLog))
                                                                                                                                                                                                                               :<|> Handler
                                                                                                                                                                                                                                      (JobOutput
                                                                                                                                                                                                                                         JobLog)))))
                                                                                                                                                                                                         :<|> (Handler
                                                                                                                                                                                                                 (JobStatus
                                                                                                                                                                                                                    'Safe
                                                                                                                                                                                                                    JobLog)
                                                                                                                                                                                                               :<|> ((JobInput
                                                                                                                                                                                                                        Maybe
                                                                                                                                                                                                                        DocumentUpload
                                                                                                                                                                                                                      -> Handler
                                                                                                                                                                                                                           (JobStatus
                                                                                                                                                                                                                              'Safe
                                                                                                                                                                                                                              JobLog))
                                                                                                                                                                                                                     :<|> (ID
                                                                                                                                                                                                                             'Unsafe
                                                                                                                                                                                                                             "job"
                                                                                                                                                                                                                           -> (Maybe
                                                                                                                                                                                                                                 Limit
                                                                                                                                                                                                                               -> Maybe
                                                                                                                                                                                                                                    Offset
                                                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                                                       JobLog))
                                                                                                                                                                                                                              :<|> ((Maybe
                                                                                                                                                                                                                                       Limit
                                                                                                                                                                                                                                     -> Maybe
                                                                                                                                                                                                                                          Offset
                                                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                                                             JobLog))
                                                                                                                                                                                                                                    :<|> Handler
                                                                                                                                                                                                                                           (JobOutput
                                                                                                                                                                                                                                              JobLog)))))))))))))))))))))))))))))))))
                                   :<|> ((NodeId
                                          -> NodeId
                                          -> Handler
                                               (NodePoly
                                                  NodeId
                                                  (Maybe Text)
                                                  Int
                                                  Int
                                                  (Maybe NodeId)
                                                  Text
                                                  UTCTime
                                                  HyperdataAny))
                                         :<|> ((NodeId
                                                -> Maybe NodeId
                                                -> Maybe NgramsType
                                                -> Handler Corpus)
                                               :<|> ((NodeId
                                                      -> Handler
                                                           (NodePoly
                                                              NodeId
                                                              (Maybe Text)
                                                              Int
                                                              Int
                                                              (Maybe NodeId)
                                                              Text
                                                              UTCTime
                                                              HyperdataAnnuaire)
                                                         :<|> ((RenameNode -> Handler [Int])
                                                               :<|> ((PostNode -> Handler [NodeId])
                                                                     :<|> ((Handler
                                                                              (JobStatus
                                                                                 'Safe JobLog)
                                                                            :<|> ((JobInput
                                                                                     Maybe PostNode
                                                                                   -> Handler
                                                                                        (JobStatus
                                                                                           'Safe
                                                                                           JobLog))
                                                                                  :<|> (ID
                                                                                          'Unsafe
                                                                                          "job"
                                                                                        -> (Maybe
                                                                                              Limit
                                                                                            -> Maybe
                                                                                                 Offset
                                                                                            -> Handler
                                                                                                 (JobStatus
                                                                                                    'Safe
                                                                                                    JobLog))
                                                                                           :<|> ((Maybe
                                                                                                    Limit
                                                                                                  -> Maybe
                                                                                                       Offset
                                                                                                  -> Handler
                                                                                                       (JobStatus
                                                                                                          'Safe
                                                                                                          JobLog))
                                                                                                 :<|> Handler
                                                                                                        (JobOutput
                                                                                                           JobLog)))))
                                                                           :<|> ((Handler
                                                                                    (JobStatus
                                                                                       'Safe JobLog)
                                                                                  :<|> ((JobInput
                                                                                           Maybe
                                                                                           FrameCalcUpload
                                                                                         -> Handler
                                                                                              (JobStatus
                                                                                                 'Safe
                                                                                                 JobLog))
                                                                                        :<|> (ID
                                                                                                'Unsafe
                                                                                                "job"
                                                                                              -> (Maybe
                                                                                                    Limit
                                                                                                  -> Maybe
                                                                                                       Offset
                                                                                                  -> Handler
                                                                                                       (JobStatus
                                                                                                          'Safe
                                                                                                          JobLog))
                                                                                                 :<|> ((Maybe
                                                                                                          Limit
                                                                                                        -> Maybe
                                                                                                             Offset
                                                                                                        -> Handler
                                                                                                             (JobStatus
                                                                                                                'Safe
                                                                                                                JobLog))
                                                                                                       :<|> Handler
                                                                                                              (JobOutput
                                                                                                                 JobLog)))))
                                                                                 :<|> ((HyperdataAnnuaire
                                                                                        -> Handler
                                                                                             Int)
                                                                                       :<|> ((Handler
                                                                                                (JobStatus
                                                                                                   'Safe
                                                                                                   JobLog)
                                                                                              :<|> ((JobInput
                                                                                                       Maybe
                                                                                                       UpdateNodeParams
                                                                                                     -> Handler
                                                                                                          (JobStatus
                                                                                                             'Safe
                                                                                                             JobLog))
                                                                                                    :<|> (ID
                                                                                                            'Unsafe
                                                                                                            "job"
                                                                                                          -> (Maybe
                                                                                                                Limit
                                                                                                              -> Maybe
                                                                                                                   Offset
                                                                                                              -> Handler
                                                                                                                   (JobStatus
                                                                                                                      'Safe
                                                                                                                      JobLog))
                                                                                                             :<|> ((Maybe
                                                                                                                      Limit
                                                                                                                    -> Maybe
                                                                                                                         Offset
                                                                                                                    -> Handler
                                                                                                                         (JobStatus
                                                                                                                            'Safe
                                                                                                                            JobLog))
                                                                                                                   :<|> Handler
                                                                                                                          (JobOutput
                                                                                                                             JobLog)))))
                                                                                             :<|> (Handler
                                                                                                     Int
                                                                                                   :<|> ((Maybe
                                                                                                            NodeType
                                                                                                          -> Maybe
                                                                                                               Int
                                                                                                          -> Maybe
                                                                                                               Int
                                                                                                          -> Handler
                                                                                                               (TableResult
                                                                                                                  (NodePoly
                                                                                                                     NodeId
                                                                                                                     (Maybe
                                                                                                                        Text)
                                                                                                                     Int
                                                                                                                     Int
                                                                                                                     (Maybe
                                                                                                                        NodeId)
                                                                                                                     Text
                                                                                                                     UTCTime
                                                                                                                     HyperdataAnnuaire)))
                                                                                                         :<|> (((Maybe
                                                                                                                   TabType
                                                                                                                 -> Maybe
                                                                                                                      NodeId
                                                                                                                 -> Maybe
                                                                                                                      Int
                                                                                                                 -> Maybe
                                                                                                                      Int
                                                                                                                 -> Maybe
                                                                                                                      OrderBy
                                                                                                                 -> Maybe
                                                                                                                      Text
                                                                                                                 -> Handler
                                                                                                                      (HashedResponse
                                                                                                                         FacetTableResult))
                                                                                                                :<|> ((TableQuery
                                                                                                                       -> Handler
                                                                                                                            FacetTableResult)
                                                                                                                      :<|> (Maybe
                                                                                                                              TabType
                                                                                                                            -> Handler
                                                                                                                                 Text)))
                                                                                                               :<|> (((TabType
                                                                                                                       -> NodeId
                                                                                                                       -> Int
                                                                                                                       -> Maybe
                                                                                                                            Int
                                                                                                                       -> Maybe
                                                                                                                            ListType
                                                                                                                       -> Maybe
                                                                                                                            Int
                                                                                                                       -> Maybe
                                                                                                                            Int
                                                                                                                       -> Maybe
                                                                                                                            OrderBy
                                                                                                                       -> Maybe
                                                                                                                            Text
                                                                                                                       -> Handler
                                                                                                                            (VersionedWithCount
                                                                                                                               NgramsTable))
                                                                                                                      :<|> ((TabType
                                                                                                                             -> NodeId
                                                                                                                             -> Versioned
                                                                                                                                  NgramsTablePatch
                                                                                                                             -> Handler
                                                                                                                                  (Versioned
                                                                                                                                     NgramsTablePatch))
                                                                                                                            :<|> ((TabType
                                                                                                                                   -> NodeId
                                                                                                                                   -> Handler
                                                                                                                                        Int)
                                                                                                                                  :<|> ((TabType
                                                                                                                                         -> NodeId
                                                                                                                                         -> Handler
                                                                                                                                              Int)
                                                                                                                                        :<|> (Handler
                                                                                                                                                (JobStatus
                                                                                                                                                   'Safe
                                                                                                                                                   JobLog)
                                                                                                                                              :<|> ((JobInput
                                                                                                                                                       Maybe
                                                                                                                                                       UpdateTableNgramsCharts
                                                                                                                                                     -> Handler
                                                                                                                                                          (JobStatus
                                                                                                                                                             'Safe
                                                                                                                                                             JobLog))
                                                                                                                                                    :<|> (ID
                                                                                                                                                            'Unsafe
                                                                                                                                                            "job"
                                                                                                                                                          -> (Maybe
                                                                                                                                                                Limit
                                                                                                                                                              -> Maybe
                                                                                                                                                                   Offset
                                                                                                                                                              -> Handler
                                                                                                                                                                   (JobStatus
                                                                                                                                                                      'Safe
                                                                                                                                                                      JobLog))
                                                                                                                                                             :<|> ((Maybe
                                                                                                                                                                      Limit
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         Offset
                                                                                                                                                                    -> Handler
                                                                                                                                                                         (JobStatus
                                                                                                                                                                            'Safe
                                                                                                                                                                            JobLog))
                                                                                                                                                                   :<|> Handler
                                                                                                                                                                          (JobOutput
                                                                                                                                                                             JobLog)))))))))
                                                                                                                     :<|> ((NodesToCategory
                                                                                                                            -> Handler
                                                                                                                                 [Int])
                                                                                                                           :<|> ((NodesToScore
                                                                                                                                  -> Handler
                                                                                                                                       [Int])
                                                                                                                                 :<|> ((SearchQuery
                                                                                                                                        -> Maybe
                                                                                                                                             Int
                                                                                                                                        -> Maybe
                                                                                                                                             Int
                                                                                                                                        -> Maybe
                                                                                                                                             OrderBy
                                                                                                                                        -> Handler
                                                                                                                                             SearchResult)
                                                                                                                                       :<|> ((ShareNodeParams
                                                                                                                                              -> Handler
                                                                                                                                                   Int)
                                                                                                                                             :<|> ((NodeId
                                                                                                                                                    -> Maybe
                                                                                                                                                         NodeId
                                                                                                                                                    -> Handler
                                                                                                                                                         Int)
                                                                                                                                                   :<|> (Handler
                                                                                                                                                           [NodeId]
                                                                                                                                                         :<|> ((Maybe
                                                                                                                                                                  TabType
                                                                                                                                                                -> Maybe
                                                                                                                                                                     Int
                                                                                                                                                                -> Maybe
                                                                                                                                                                     Int
                                                                                                                                                                -> Maybe
                                                                                                                                                                     OrderBy
                                                                                                                                                                -> Handler
                                                                                                                                                                     [FacetDoc])
                                                                                                                                                               :<|> (((Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                       -> TabType
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            Int
                                                                                                                                                                       -> Handler
                                                                                                                                                                            (HashedResponse
                                                                                                                                                                               Metrics))
                                                                                                                                                                      :<|> ((Maybe
                                                                                                                                                                               NodeId
                                                                                                                                                                             -> TabType
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  Int
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  ())
                                                                                                                                                                            :<|> (Maybe
                                                                                                                                                                                    NodeId
                                                                                                                                                                                  -> TabType
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       Text)))
                                                                                                                                                                     :<|> (((Maybe
                                                                                                                                                                               UTCTime
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  UTCTime
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  NodeId
                                                                                                                                                                             -> TabType
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  (HashedResponse
                                                                                                                                                                                     (ChartMetrics
                                                                                                                                                                                        Histo)))
                                                                                                                                                                            :<|> ((Maybe
                                                                                                                                                                                     NodeId
                                                                                                                                                                                   -> TabType
                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                        Int
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        ())
                                                                                                                                                                                  :<|> (Maybe
                                                                                                                                                                                          NodeId
                                                                                                                                                                                        -> TabType
                                                                                                                                                                                        -> Handler
                                                                                                                                                                                             Text)))
                                                                                                                                                                           :<|> (((Maybe
                                                                                                                                                                                     UTCTime
                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                        UTCTime
                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                        NodeId
                                                                                                                                                                                   -> TabType
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        (HashedResponse
                                                                                                                                                                                           (ChartMetrics
                                                                                                                                                                                              Histo)))
                                                                                                                                                                                  :<|> ((Maybe
                                                                                                                                                                                           NodeId
                                                                                                                                                                                         -> TabType
                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                              Int
                                                                                                                                                                                         -> Handler
                                                                                                                                                                                              ())
                                                                                                                                                                                        :<|> (Maybe
                                                                                                                                                                                                NodeId
                                                                                                                                                                                              -> TabType
                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                   Text)))
                                                                                                                                                                                 :<|> (((Maybe
                                                                                                                                                                                           UTCTime
                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                              UTCTime
                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                              NodeId
                                                                                                                                                                                         -> TabType
                                                                                                                                                                                         -> ListType
                                                                                                                                                                                         -> Handler
                                                                                                                                                                                              (HashedResponse
                                                                                                                                                                                                 (ChartMetrics
                                                                                                                                                                                                    (Vector
                                                                                                                                                                                                       NgramsTree))))
                                                                                                                                                                                        :<|> ((Maybe
                                                                                                                                                                                                 NodeId
                                                                                                                                                                                               -> TabType
                                                                                                                                                                                               -> ListType
                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                    ())
                                                                                                                                                                                              :<|> (Maybe
                                                                                                                                                                                                      NodeId
                                                                                                                                                                                                    -> TabType
                                                                                                                                                                                                    -> ListType
                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                         Text)))
                                                                                                                                                                                       :<|> (((Maybe
                                                                                                                                                                                                 NodeId
                                                                                                                                                                                               -> Maybe
                                                                                                                                                                                                    Int
                                                                                                                                                                                               -> Maybe
                                                                                                                                                                                                    Int
                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                    SVG)
                                                                                                                                                                                              :<|> (Maybe
                                                                                                                                                                                                      NodeId
                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                         NodeId))
                                                                                                                                                                                             :<|> ((NodeId
                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                         [Int])
                                                                                                                                                                                                   :<|> ((NodeId
                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                               Int)
                                                                                                                                                                                                         :<|> (Handler
                                                                                                                                                                                                                 (Headers
                                                                                                                                                                                                                    '[Header
                                                                                                                                                                                                                        "Content-Type"
                                                                                                                                                                                                                        Text]
                                                                                                                                                                                                                    BSResponse)
                                                                                                                                                                                                               :<|> ((Handler
                                                                                                                                                                                                                        (JobStatus
                                                                                                                                                                                                                           'Safe
                                                                                                                                                                                                                           JobLog)
                                                                                                                                                                                                                      :<|> ((JobInput
                                                                                                                                                                                                                               Maybe
                                                                                                                                                                                                                               NewWithFile
                                                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                                                  (JobStatus
                                                                                                                                                                                                                                     'Safe
                                                                                                                                                                                                                                     JobLog))
                                                                                                                                                                                                                            :<|> (ID
                                                                                                                                                                                                                                    'Unsafe
                                                                                                                                                                                                                                    "job"
                                                                                                                                                                                                                                  -> (Maybe
                                                                                                                                                                                                                                        Limit
                                                                                                                                                                                                                                      -> Maybe
                                                                                                                                                                                                                                           Offset
                                                                                                                                                                                                                                      -> Handler
                                                                                                                                                                                                                                           (JobStatus
                                                                                                                                                                                                                                              'Safe
                                                                                                                                                                                                                                              JobLog))
                                                                                                                                                                                                                                     :<|> ((Maybe
                                                                                                                                                                                                                                              Limit
                                                                                                                                                                                                                                            -> Maybe
                                                                                                                                                                                                                                                 Offset
                                                                                                                                                                                                                                            -> Handler
                                                                                                                                                                                                                                                 (JobStatus
                                                                                                                                                                                                                                                    'Safe
                                                                                                                                                                                                                                                    JobLog))
                                                                                                                                                                                                                                           :<|> Handler
                                                                                                                                                                                                                                                  (JobOutput
                                                                                                                                                                                                                                                     JobLog)))))
                                                                                                                                                                                                                     :<|> ((Handler
                                                                                                                                                                                                                              (JobStatus
                                                                                                                                                                                                                                 'Safe
                                                                                                                                                                                                                                 JobLog)
                                                                                                                                                                                                                            :<|> ((JobInput
                                                                                                                                                                                                                                     Maybe
                                                                                                                                                                                                                                     Params
                                                                                                                                                                                                                                   -> Handler
                                                                                                                                                                                                                                        (JobStatus
                                                                                                                                                                                                                                           'Safe
                                                                                                                                                                                                                                           JobLog))
                                                                                                                                                                                                                                  :<|> (ID
                                                                                                                                                                                                                                          'Unsafe
                                                                                                                                                                                                                                          "job"
                                                                                                                                                                                                                                        -> (Maybe
                                                                                                                                                                                                                                              Limit
                                                                                                                                                                                                                                            -> Maybe
                                                                                                                                                                                                                                                 Offset
                                                                                                                                                                                                                                            -> Handler
                                                                                                                                                                                                                                                 (JobStatus
                                                                                                                                                                                                                                                    'Safe
                                                                                                                                                                                                                                                    JobLog))
                                                                                                                                                                                                                                           :<|> ((Maybe
                                                                                                                                                                                                                                                    Limit
                                                                                                                                                                                                                                                  -> Maybe
                                                                                                                                                                                                                                                       Offset
                                                                                                                                                                                                                                                  -> Handler
                                                                                                                                                                                                                                                       (JobStatus
                                                                                                                                                                                                                                                          'Safe
                                                                                                                                                                                                                                                          JobLog))
                                                                                                                                                                                                                                                 :<|> Handler
                                                                                                                                                                                                                                                        (JobOutput
                                                                                                                                                                                                                                                           JobLog)))))
                                                                                                                                                                                                                           :<|> (Handler
                                                                                                                                                                                                                                   (JobStatus
                                                                                                                                                                                                                                      'Safe
                                                                                                                                                                                                                                      JobLog)
                                                                                                                                                                                                                                 :<|> ((JobInput
                                                                                                                                                                                                                                          Maybe
                                                                                                                                                                                                                                          DocumentUpload
                                                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                                                             (JobStatus
                                                                                                                                                                                                                                                'Safe
                                                                                                                                                                                                                                                JobLog))
                                                                                                                                                                                                                                       :<|> (ID
                                                                                                                                                                                                                                               'Unsafe
                                                                                                                                                                                                                                               "job"
                                                                                                                                                                                                                                             -> (Maybe
                                                                                                                                                                                                                                                   Limit
                                                                                                                                                                                                                                                 -> Maybe
                                                                                                                                                                                                                                                      Offset
                                                                                                                                                                                                                                                 -> Handler
                                                                                                                                                                                                                                                      (JobStatus
                                                                                                                                                                                                                                                         'Safe
                                                                                                                                                                                                                                                         JobLog))
                                                                                                                                                                                                                                                :<|> ((Maybe
                                                                                                                                                                                                                                                         Limit
                                                                                                                                                                                                                                                       -> Maybe
                                                                                                                                                                                                                                                            Offset
                                                                                                                                                                                                                                                       -> Handler
                                                                                                                                                                                                                                                            (JobStatus
                                                                                                                                                                                                                                                               'Safe
                                                                                                                                                                                                                                                               JobLog))
                                                                                                                                                                                                                                                      :<|> Handler
                                                                                                                                                                                                                                                             (JobOutput
                                                                                                                                                                                                                                                                JobLog)))))))))))))))))))))))))))))))))
                                                     :<|> ((NodeId
                                                            -> (Handler (JobStatus 'Safe JobLog)
                                                                :<|> ((JobInput
                                                                         Maybe AddContactParams
                                                                       -> Handler
                                                                            (JobStatus
                                                                               'Safe JobLog))
                                                                      :<|> (ID 'Unsafe "job"
                                                                            -> (Maybe Limit
                                                                                -> Maybe Offset
                                                                                -> Handler
                                                                                     (JobStatus
                                                                                        'Safe
                                                                                        JobLog))
                                                                               :<|> ((Maybe Limit
                                                                                      -> Maybe
                                                                                           Offset
                                                                                      -> Handler
                                                                                           (JobStatus
                                                                                              'Safe
                                                                                              JobLog))
                                                                                     :<|> Handler
                                                                                            (JobOutput
                                                                                               JobLog)))))
                                                               :<|> (NodeId
                                                                     -> Handler
                                                                          (NodePoly
                                                                             NodeId
                                                                             (Maybe Text)
                                                                             Int
                                                                             Int
                                                                             (Maybe NodeId)
                                                                             Text
                                                                             UTCTime
                                                                             HyperdataContact)))
                                                           :<|> ((NodeId
                                                                  -> (TabType
                                                                      -> NodeId
                                                                      -> Int
                                                                      -> Maybe Int
                                                                      -> Maybe ListType
                                                                      -> Maybe Int
                                                                      -> Maybe Int
                                                                      -> Maybe OrderBy
                                                                      -> Maybe Text
                                                                      -> Handler
                                                                           (VersionedWithCount
                                                                              NgramsTable))
                                                                     :<|> ((TabType
                                                                            -> NodeId
                                                                            -> Versioned
                                                                                 NgramsTablePatch
                                                                            -> Handler
                                                                                 (Versioned
                                                                                    NgramsTablePatch))
                                                                           :<|> ((TabType
                                                                                  -> NodeId
                                                                                  -> Handler Int)
                                                                                 :<|> ((TabType
                                                                                        -> NodeId
                                                                                        -> Handler
                                                                                             Int)
                                                                                       :<|> (Handler
                                                                                               (JobStatus
                                                                                                  'Safe
                                                                                                  JobLog)
                                                                                             :<|> ((JobInput
                                                                                                      Maybe
                                                                                                      UpdateTableNgramsCharts
                                                                                                    -> Handler
                                                                                                         (JobStatus
                                                                                                            'Safe
                                                                                                            JobLog))
                                                                                                   :<|> (ID
                                                                                                           'Unsafe
                                                                                                           "job"
                                                                                                         -> (Maybe
                                                                                                               Limit
                                                                                                             -> Maybe
                                                                                                                  Offset
                                                                                                             -> Handler
                                                                                                                  (JobStatus
                                                                                                                     'Safe
                                                                                                                     JobLog))
                                                                                                            :<|> ((Maybe
                                                                                                                     Limit
                                                                                                                   -> Maybe
                                                                                                                        Offset
                                                                                                                   -> Handler
                                                                                                                        (JobStatus
                                                                                                                           'Safe
                                                                                                                           JobLog))
                                                                                                                  :<|> Handler
                                                                                                                         (JobOutput
                                                                                                                            JobLog)))))))))
                                                                 :<|> ((Query -> Handler Counts)
                                                                       :<|> ((NodeId
                                                                              -> Handler
                                                                                   HyperdataGraphAPI
                                                                                 :<|> ((Handler
                                                                                          (JobStatus
                                                                                             'Safe
                                                                                             JobLog)
                                                                                        :<|> ((JobInput
                                                                                                 Maybe
                                                                                                 ()
                                                                                               -> Handler
                                                                                                    (JobStatus
                                                                                                       'Safe
                                                                                                       JobLog))
                                                                                              :<|> (ID
                                                                                                      'Unsafe
                                                                                                      "job"
                                                                                                    -> (Maybe
                                                                                                          Limit
                                                                                                        -> Maybe
                                                                                                             Offset
                                                                                                        -> Handler
                                                                                                             (JobStatus
                                                                                                                'Safe
                                                                                                                JobLog))
                                                                                                       :<|> ((Maybe
                                                                                                                Limit
                                                                                                              -> Maybe
                                                                                                                   Offset
                                                                                                              -> Handler
                                                                                                                   (JobStatus
                                                                                                                      'Safe
                                                                                                                      JobLog))
                                                                                                             :<|> Handler
                                                                                                                    (JobOutput
                                                                                                                       JobLog)))))
                                                                                       :<|> ((HyperdataGraphAPI
                                                                                              -> Handler
                                                                                                   NodeId)
                                                                                             :<|> (Handler
                                                                                                     (Headers
                                                                                                        '[Header
                                                                                                            "Content-Disposition"
                                                                                                            Text]
                                                                                                        Graph)
                                                                                                   :<|> (Handler
                                                                                                           GraphVersions
                                                                                                         :<|> Handler
                                                                                                                Graph)))))
                                                                             :<|> ((NodeId
                                                                                    -> ([NodeType]
                                                                                        -> Handler
                                                                                             (Tree
                                                                                                NodeTree))
                                                                                       :<|> ([NodeType]
                                                                                             -> Handler
                                                                                                  (Tree
                                                                                                     NodeTree)))
                                                                                   :<|> ((NodeId
                                                                                          -> Handler
                                                                                               (JobStatus
                                                                                                  'Safe
                                                                                                  JobLog)
                                                                                             :<|> ((JobInput
                                                                                                      Maybe
                                                                                                      NewWithForm
                                                                                                    -> Handler
                                                                                                         (JobStatus
                                                                                                            'Safe
                                                                                                            JobLog))
                                                                                                   :<|> (ID
                                                                                                           'Unsafe
                                                                                                           "job"
                                                                                                         -> (Maybe
                                                                                                               Limit
                                                                                                             -> Maybe
                                                                                                                  Offset
                                                                                                             -> Handler
                                                                                                                  (JobStatus
                                                                                                                     'Safe
                                                                                                                     JobLog))
                                                                                                            :<|> ((Maybe
                                                                                                                     Limit
                                                                                                                   -> Maybe
                                                                                                                        Offset
                                                                                                                   -> Handler
                                                                                                                        (JobStatus
                                                                                                                           'Safe
                                                                                                                           JobLog))
                                                                                                                  :<|> Handler
                                                                                                                         (JobOutput
                                                                                                                            JobLog)))))
                                                                                         :<|> ((NodeId
                                                                                                -> Handler
                                                                                                     (JobStatus
                                                                                                        'Safe
                                                                                                        JobLog)
                                                                                                   :<|> ((JobInput
                                                                                                            Maybe
                                                                                                            WithQuery
                                                                                                          -> Handler
                                                                                                               (JobStatus
                                                                                                                  'Safe
                                                                                                                  JobLog))
                                                                                                         :<|> (ID
                                                                                                                 'Unsafe
                                                                                                                 "job"
                                                                                                               -> (Maybe
                                                                                                                     Limit
                                                                                                                   -> Maybe
                                                                                                                        Offset
                                                                                                                   -> Handler
                                                                                                                        (JobStatus
                                                                                                                           'Safe
                                                                                                                           JobLog))
                                                                                                                  :<|> ((Maybe
                                                                                                                           Limit
                                                                                                                         -> Maybe
                                                                                                                              Offset
                                                                                                                         -> Handler
                                                                                                                              (JobStatus
                                                                                                                                 'Safe
                                                                                                                                 JobLog))
                                                                                                                        :<|> Handler
                                                                                                                               (JobOutput
                                                                                                                                  JobLog)))))
                                                                                               :<|> ((NodeId
                                                                                                      -> Handler
                                                                                                           (Headers
                                                                                                              '[Header
                                                                                                                  "Content-Disposition"
                                                                                                                  Text]
                                                                                                              (Map
                                                                                                                 NgramsType
                                                                                                                 (Versioned
                                                                                                                    NgramsTableMap))))
                                                                                                     :<|> ((NodeId
                                                                                                            -> Handler
                                                                                                                 (JobStatus
                                                                                                                    'Safe
                                                                                                                    JobLog)
                                                                                                               :<|> ((JobInput
                                                                                                                        Maybe
                                                                                                                        WithFile
                                                                                                                      -> Handler
                                                                                                                           (JobStatus
                                                                                                                              'Safe
                                                                                                                              JobLog))
                                                                                                                     :<|> (ID
                                                                                                                             'Unsafe
                                                                                                                             "job"
                                                                                                                           -> (Maybe
                                                                                                                                 Limit
                                                                                                                               -> Maybe
                                                                                                                                    Offset
                                                                                                                               -> Handler
                                                                                                                                    (JobStatus
                                                                                                                                       'Safe
                                                                                                                                       JobLog))
                                                                                                                              :<|> ((Maybe
                                                                                                                                       Limit
                                                                                                                                     -> Maybe
                                                                                                                                          Offset
                                                                                                                                     -> Handler
                                                                                                                                          (JobStatus
                                                                                                                                             'Safe
                                                                                                                                             JobLog))
                                                                                                                                    :<|> Handler
                                                                                                                                           (JobOutput
                                                                                                                                              JobLog)))))
                                                                                                           :<|> (NodeId
                                                                                                                 -> Handler
                                                                                                                      (JobStatus
                                                                                                                         'Safe
                                                                                                                         JobLog)
                                                                                                                    :<|> ((JobInput
                                                                                                                             Maybe
                                                                                                                             WithTextFile
                                                                                                                           -> Handler
                                                                                                                                (JobStatus
                                                                                                                                   'Safe
                                                                                                                                   JobLog))
                                                                                                                          :<|> (ID
                                                                                                                                  'Unsafe
                                                                                                                                  "job"
                                                                                                                                -> (Maybe
                                                                                                                                      Limit
                                                                                                                                    -> Maybe
                                                                                                                                         Offset
                                                                                                                                    -> Handler
                                                                                                                                         (JobStatus
                                                                                                                                            'Safe
                                                                                                                                            JobLog))
                                                                                                                                   :<|> ((Maybe
                                                                                                                                            Limit
                                                                                                                                          -> Maybe
                                                                                                                                               Offset
                                                                                                                                          -> Handler
                                                                                                                                               (JobStatus
                                                                                                                                                  'Safe
                                                                                                                                                  JobLog))
                                                                                                                                         :<|> Handler
                                                                                                                                                (JobOutput
                                                                                                                                                   JobLog))))))))))))))))))))
                   :<|> (Handler [PublicData]
                         :<|> (NodeId
                               -> Handler (Headers '[Header "Content-Type" Text] BSResponse))))))
      :<|> ((AuthResult AuthenticatedUser
             -> (GQLRequest -> Handler GQLResponse) :<|> Handler ByteString)
            :<|> Tagged Handler Application))
serv <- env -> IO (Server API)
forall env. (Typeable env, EnvC env) => env -> IO (Server API)
server env
env
  (Store
ekgStore, Middleware
ekgMid) <- Proxy API -> IO (Store, Middleware)
forall api. HasEndpoint api => Proxy api -> IO (Store, Middleware)
newEkgStore Proxy API
api
  String
ekgDir <- (String -> ShowS
</> String
"ekg-assets") ShowS -> IO String -> IO String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO String
getDataDir
  Application -> IO Application
forall (m :: * -> *) a. Monad m => a -> m a
return (Application -> IO Application) -> Application -> IO Application
forall a b. (a -> b) -> a -> b
$ Middleware
ekgMid Middleware -> Middleware
forall a b. (a -> b) -> a -> b
$ Proxy (EkgAPI :<|> API)
-> Context AuthContext -> Server (EkgAPI :<|> API) -> Application
forall api (context :: [*]).
(HasServer api context,
 HasContextEntry
   (context .++ DefaultErrorFormatters) ErrorFormatters) =>
Proxy api -> Context context -> Server api -> Application
serveWithContext Proxy (EkgAPI :<|> API)
apiWithEkg Context AuthContext
cfg
    (String -> Store -> Server EkgAPI
ekgServer String
ekgDir Store
ekgStore ((Handler Sample :<|> ([Text] -> Handler Value))
 :<|> Tagged Handler Application)
-> ((Handler Value
     :<|> (Handler
             (SwaggerUiHtml "swagger-ui" ("swagger.json" :> Get '[JSON] Value))
           :<|> (Handler
                   (SwaggerUiHtml "swagger-ui" ("swagger.json" :> Get '[JSON] Value))
                 :<|> Tagged Handler Application)))
    :<|> (((AuthRequest -> Handler AuthResponse)
           :<|> (Handler Text
                 :<|> ((AuthResult AuthenticatedUser
                        -> ((Handler [Node HyperdataUser] :<|> Handler Int)
                            :<|> ([NodeId] -> Handler Int))
                           :<|> ((NodeId
                                  -> Handler
                                       (NodePoly
                                          NodeId
                                          (Maybe Text)
                                          Int
                                          Int
                                          (Maybe NodeId)
                                          Text
                                          UTCTime
                                          HyperdataAny)
                                     :<|> ((RenameNode -> Handler [Int])
                                           :<|> ((PostNode -> Handler [NodeId])
                                                 :<|> ((Handler (JobStatus 'Safe JobLog)
                                                        :<|> ((JobInput Maybe PostNode
                                                               -> Handler (JobStatus 'Safe JobLog))
                                                              :<|> (ID 'Unsafe "job"
                                                                    -> (Maybe Limit
                                                                        -> Maybe Offset
                                                                        -> Handler
                                                                             (JobStatus
                                                                                'Safe JobLog))
                                                                       :<|> ((Maybe Limit
                                                                              -> Maybe Offset
                                                                              -> Handler
                                                                                   (JobStatus
                                                                                      'Safe JobLog))
                                                                             :<|> Handler
                                                                                    (JobOutput
                                                                                       JobLog)))))
                                                       :<|> ((Handler (JobStatus 'Safe JobLog)
                                                              :<|> ((JobInput Maybe FrameCalcUpload
                                                                     -> Handler
                                                                          (JobStatus 'Safe JobLog))
                                                                    :<|> (ID 'Unsafe "job"
                                                                          -> (Maybe Limit
                                                                              -> Maybe Offset
                                                                              -> Handler
                                                                                   (JobStatus
                                                                                      'Safe JobLog))
                                                                             :<|> ((Maybe Limit
                                                                                    -> Maybe Offset
                                                                                    -> Handler
                                                                                         (JobStatus
                                                                                            'Safe
                                                                                            JobLog))
                                                                                   :<|> Handler
                                                                                          (JobOutput
                                                                                             JobLog)))))
                                                             :<|> ((HyperdataAny -> Handler Int)
                                                                   :<|> ((Handler
                                                                            (JobStatus 'Safe JobLog)
                                                                          :<|> ((JobInput
                                                                                   Maybe
                                                                                   UpdateNodeParams
                                                                                 -> Handler
                                                                                      (JobStatus
                                                                                         'Safe
                                                                                         JobLog))
                                                                                :<|> (ID
                                                                                        'Unsafe
                                                                                        "job"
                                                                                      -> (Maybe
                                                                                            Limit
                                                                                          -> Maybe
                                                                                               Offset
                                                                                          -> Handler
                                                                                               (JobStatus
                                                                                                  'Safe
                                                                                                  JobLog))
                                                                                         :<|> ((Maybe
                                                                                                  Limit
                                                                                                -> Maybe
                                                                                                     Offset
                                                                                                -> Handler
                                                                                                     (JobStatus
                                                                                                        'Safe
                                                                                                        JobLog))
                                                                                               :<|> Handler
                                                                                                      (JobOutput
                                                                                                         JobLog)))))
                                                                         :<|> (Handler Int
                                                                               :<|> ((Maybe NodeType
                                                                                      -> Maybe Int
                                                                                      -> Maybe Int
                                                                                      -> Handler
                                                                                           (TableResult
                                                                                              (NodePoly
                                                                                                 NodeId
                                                                                                 (Maybe
                                                                                                    Text)
                                                                                                 Int
                                                                                                 Int
                                                                                                 (Maybe
                                                                                                    NodeId)
                                                                                                 Text
                                                                                                 UTCTime
                                                                                                 HyperdataAny)))
                                                                                     :<|> (((Maybe
                                                                                               TabType
                                                                                             -> Maybe
                                                                                                  NodeId
                                                                                             -> Maybe
                                                                                                  Int
                                                                                             -> Maybe
                                                                                                  Int
                                                                                             -> Maybe
                                                                                                  OrderBy
                                                                                             -> Maybe
                                                                                                  Text
                                                                                             -> Handler
                                                                                                  (HashedResponse
                                                                                                     FacetTableResult))
                                                                                            :<|> ((TableQuery
                                                                                                   -> Handler
                                                                                                        FacetTableResult)
                                                                                                  :<|> (Maybe
                                                                                                          TabType
                                                                                                        -> Handler
                                                                                                             Text)))
                                                                                           :<|> (((TabType
                                                                                                   -> NodeId
                                                                                                   -> Int
                                                                                                   -> Maybe
                                                                                                        Int
                                                                                                   -> Maybe
                                                                                                        ListType
                                                                                                   -> Maybe
                                                                                                        Int
                                                                                                   -> Maybe
                                                                                                        Int
                                                                                                   -> Maybe
                                                                                                        OrderBy
                                                                                                   -> Maybe
                                                                                                        Text
                                                                                                   -> Handler
                                                                                                        (VersionedWithCount
                                                                                                           NgramsTable))
                                                                                                  :<|> ((TabType
                                                                                                         -> NodeId
                                                                                                         -> Versioned
                                                                                                              NgramsTablePatch
                                                                                                         -> Handler
                                                                                                              (Versioned
                                                                                                                 NgramsTablePatch))
                                                                                                        :<|> ((TabType
                                                                                                               -> NodeId
                                                                                                               -> Handler
                                                                                                                    Int)
                                                                                                              :<|> ((TabType
                                                                                                                     -> NodeId
                                                                                                                     -> Handler
                                                                                                                          Int)
                                                                                                                    :<|> (Handler
                                                                                                                            (JobStatus
                                                                                                                               'Safe
                                                                                                                               JobLog)
                                                                                                                          :<|> ((JobInput
                                                                                                                                   Maybe
                                                                                                                                   UpdateTableNgramsCharts
                                                                                                                                 -> Handler
                                                                                                                                      (JobStatus
                                                                                                                                         'Safe
                                                                                                                                         JobLog))
                                                                                                                                :<|> (ID
                                                                                                                                        'Unsafe
                                                                                                                                        "job"
                                                                                                                                      -> (Maybe
                                                                                                                                            Limit
                                                                                                                                          -> Maybe
                                                                                                                                               Offset
                                                                                                                                          -> Handler
                                                                                                                                               (JobStatus
                                                                                                                                                  'Safe
                                                                                                                                                  JobLog))
                                                                                                                                         :<|> ((Maybe
                                                                                                                                                  Limit
                                                                                                                                                -> Maybe
                                                                                                                                                     Offset
                                                                                                                                                -> Handler
                                                                                                                                                     (JobStatus
                                                                                                                                                        'Safe
                                                                                                                                                        JobLog))
                                                                                                                                               :<|> Handler
                                                                                                                                                      (JobOutput
                                                                                                                                                         JobLog)))))))))
                                                                                                 :<|> ((NodesToCategory
                                                                                                        -> Handler
                                                                                                             [Int])
                                                                                                       :<|> ((NodesToScore
                                                                                                              -> Handler
                                                                                                                   [Int])
                                                                                                             :<|> ((SearchQuery
                                                                                                                    -> Maybe
                                                                                                                         Int
                                                                                                                    -> Maybe
                                                                                                                         Int
                                                                                                                    -> Maybe
                                                                                                                         OrderBy
                                                                                                                    -> Handler
                                                                                                                         SearchResult)
                                                                                                                   :<|> ((ShareNodeParams
                                                                                                                          -> Handler
                                                                                                                               Int)
                                                                                                                         :<|> ((NodeId
                                                                                                                                -> Maybe
                                                                                                                                     NodeId
                                                                                                                                -> Handler
                                                                                                                                     Int)
                                                                                                                               :<|> (Handler
                                                                                                                                       [NodeId]
                                                                                                                                     :<|> ((Maybe
                                                                                                                                              TabType
                                                                                                                                            -> Maybe
                                                                                                                                                 Int
                                                                                                                                            -> Maybe
                                                                                                                                                 Int
                                                                                                                                            -> Maybe
                                                                                                                                                 OrderBy
                                                                                                                                            -> Handler
                                                                                                                                                 [FacetDoc])
                                                                                                                                           :<|> (((Maybe
                                                                                                                                                     NodeId
                                                                                                                                                   -> TabType
                                                                                                                                                   -> Maybe
                                                                                                                                                        Int
                                                                                                                                                   -> Handler
                                                                                                                                                        (HashedResponse
                                                                                                                                                           Metrics))
                                                                                                                                                  :<|> ((Maybe
                                                                                                                                                           NodeId
                                                                                                                                                         -> TabType
                                                                                                                                                         -> Maybe
                                                                                                                                                              Int
                                                                                                                                                         -> Handler
                                                                                                                                                              ())
                                                                                                                                                        :<|> (Maybe
                                                                                                                                                                NodeId
                                                                                                                                                              -> TabType
                                                                                                                                                              -> Handler
                                                                                                                                                                   Text)))
                                                                                                                                                 :<|> (((Maybe
                                                                                                                                                           UTCTime
                                                                                                                                                         -> Maybe
                                                                                                                                                              UTCTime
                                                                                                                                                         -> Maybe
                                                                                                                                                              NodeId
                                                                                                                                                         -> TabType
                                                                                                                                                         -> Handler
                                                                                                                                                              (HashedResponse
                                                                                                                                                                 (ChartMetrics
                                                                                                                                                                    Histo)))
                                                                                                                                                        :<|> ((Maybe
                                                                                                                                                                 NodeId
                                                                                                                                                               -> TabType
                                                                                                                                                               -> Maybe
                                                                                                                                                                    Int
                                                                                                                                                               -> Handler
                                                                                                                                                                    ())
                                                                                                                                                              :<|> (Maybe
                                                                                                                                                                      NodeId
                                                                                                                                                                    -> TabType
                                                                                                                                                                    -> Handler
                                                                                                                                                                         Text)))
                                                                                                                                                       :<|> (((Maybe
                                                                                                                                                                 UTCTime
                                                                                                                                                               -> Maybe
                                                                                                                                                                    UTCTime
                                                                                                                                                               -> Maybe
                                                                                                                                                                    NodeId
                                                                                                                                                               -> TabType
                                                                                                                                                               -> Handler
                                                                                                                                                                    (HashedResponse
                                                                                                                                                                       (ChartMetrics
                                                                                                                                                                          Histo)))
                                                                                                                                                              :<|> ((Maybe
                                                                                                                                                                       NodeId
                                                                                                                                                                     -> TabType
                                                                                                                                                                     -> Maybe
                                                                                                                                                                          Int
                                                                                                                                                                     -> Handler
                                                                                                                                                                          ())
                                                                                                                                                                    :<|> (Maybe
                                                                                                                                                                            NodeId
                                                                                                                                                                          -> TabType
                                                                                                                                                                          -> Handler
                                                                                                                                                                               Text)))
                                                                                                                                                             :<|> (((Maybe
                                                                                                                                                                       UTCTime
                                                                                                                                                                     -> Maybe
                                                                                                                                                                          UTCTime
                                                                                                                                                                     -> Maybe
                                                                                                                                                                          NodeId
                                                                                                                                                                     -> TabType
                                                                                                                                                                     -> ListType
                                                                                                                                                                     -> Handler
                                                                                                                                                                          (HashedResponse
                                                                                                                                                                             (ChartMetrics
                                                                                                                                                                                (Vector
                                                                                                                                                                                   NgramsTree))))
                                                                                                                                                                    :<|> ((Maybe
                                                                                                                                                                             NodeId
                                                                                                                                                                           -> TabType
                                                                                                                                                                           -> ListType
                                                                                                                                                                           -> Handler
                                                                                                                                                                                ())
                                                                                                                                                                          :<|> (Maybe
                                                                                                                                                                                  NodeId
                                                                                                                                                                                -> TabType
                                                                                                                                                                                -> ListType
                                                                                                                                                                                -> Handler
                                                                                                                                                                                     Text)))
                                                                                                                                                                   :<|> (((Maybe
                                                                                                                                                                             NodeId
                                                                                                                                                                           -> Maybe
                                                                                                                                                                                Int
                                                                                                                                                                           -> Maybe
                                                                                                                                                                                Int
                                                                                                                                                                           -> Handler
                                                                                                                                                                                SVG)
                                                                                                                                                                          :<|> (Maybe
                                                                                                                                                                                  NodeId
                                                                                                                                                                                -> Handler
                                                                                                                                                                                     NodeId))
                                                                                                                                                                         :<|> ((NodeId
                                                                                                                                                                                -> Handler
                                                                                                                                                                                     [Int])
                                                                                                                                                                               :<|> ((NodeId
                                                                                                                                                                                      -> Handler
                                                                                                                                                                                           Int)
                                                                                                                                                                                     :<|> (Handler
                                                                                                                                                                                             (Headers
                                                                                                                                                                                                '[Header
                                                                                                                                                                                                    "Content-Type"
                                                                                                                                                                                                    Text]
                                                                                                                                                                                                BSResponse)
                                                                                                                                                                                           :<|> ((Handler
                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                       JobLog)
                                                                                                                                                                                                  :<|> ((JobInput
                                                                                                                                                                                                           Maybe
                                                                                                                                                                                                           NewWithFile
                                                                                                                                                                                                         -> Handler
                                                                                                                                                                                                              (JobStatus
                                                                                                                                                                                                                 'Safe
                                                                                                                                                                                                                 JobLog))
                                                                                                                                                                                                        :<|> (ID
                                                                                                                                                                                                                'Unsafe
                                                                                                                                                                                                                "job"
                                                                                                                                                                                                              -> (Maybe
                                                                                                                                                                                                                    Limit
                                                                                                                                                                                                                  -> Maybe
                                                                                                                                                                                                                       Offset
                                                                                                                                                                                                                  -> Handler
                                                                                                                                                                                                                       (JobStatus
                                                                                                                                                                                                                          'Safe
                                                                                                                                                                                                                          JobLog))
                                                                                                                                                                                                                 :<|> ((Maybe
                                                                                                                                                                                                                          Limit
                                                                                                                                                                                                                        -> Maybe
                                                                                                                                                                                                                             Offset
                                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                                             (JobStatus
                                                                                                                                                                                                                                'Safe
                                                                                                                                                                                                                                JobLog))
                                                                                                                                                                                                                       :<|> Handler
                                                                                                                                                                                                                              (JobOutput
                                                                                                                                                                                                                                 JobLog)))))
                                                                                                                                                                                                 :<|> ((Handler
                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                             JobLog)
                                                                                                                                                                                                        :<|> ((JobInput
                                                                                                                                                                                                                 Maybe
                                                                                                                                                                                                                 Params
                                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                                       JobLog))
                                                                                                                                                                                                              :<|> (ID
                                                                                                                                                                                                                      'Unsafe
                                                                                                                                                                                                                      "job"
                                                                                                                                                                                                                    -> (Maybe
                                                                                                                                                                                                                          Limit
                                                                                                                                                                                                                        -> Maybe
                                                                                                                                                                                                                             Offset
                                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                                             (JobStatus
                                                                                                                                                                                                                                'Safe
                                                                                                                                                                                                                                JobLog))
                                                                                                                                                                                                                       :<|> ((Maybe
                                                                                                                                                                                                                                Limit
                                                                                                                                                                                                                              -> Maybe
                                                                                                                                                                                                                                   Offset
                                                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                                                   (JobStatus
                                                                                                                                                                                                                                      'Safe
                                                                                                                                                                                                                                      JobLog))
                                                                                                                                                                                                                             :<|> Handler
                                                                                                                                                                                                                                    (JobOutput
                                                                                                                                                                                                                                       JobLog)))))
                                                                                                                                                                                                       :<|> (Handler
                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                  JobLog)
                                                                                                                                                                                                             :<|> ((JobInput
                                                                                                                                                                                                                      Maybe
                                                                                                                                                                                                                      DocumentUpload
                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                   :<|> (ID
                                                                                                                                                                                                                           'Unsafe
                                                                                                                                                                                                                           "job"
                                                                                                                                                                                                                         -> (Maybe
                                                                                                                                                                                                                               Limit
                                                                                                                                                                                                                             -> Maybe
                                                                                                                                                                                                                                  Offset
                                                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                                                  (JobStatus
                                                                                                                                                                                                                                     'Safe
                                                                                                                                                                                                                                     JobLog))
                                                                                                                                                                                                                            :<|> ((Maybe
                                                                                                                                                                                                                                     Limit
                                                                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                                                                        Offset
                                                                                                                                                                                                                                   -> Handler
                                                                                                                                                                                                                                        (JobStatus
                                                                                                                                                                                                                                           'Safe
                                                                                                                                                                                                                                           JobLog))
                                                                                                                                                                                                                                  :<|> Handler
                                                                                                                                                                                                                                         (JobOutput
                                                                                                                                                                                                                                            JobLog)))))))))))))))))))))))))))))))))
                                 :<|> ((NodeId
                                        -> Handler
                                             (NodePoly
                                                NodeId
                                                (Maybe Text)
                                                Int
                                                Int
                                                (Maybe NodeId)
                                                Text
                                                UTCTime
                                                HyperdataCorpus)
                                           :<|> ((RenameNode -> Handler [Int])
                                                 :<|> ((PostNode -> Handler [NodeId])
                                                       :<|> ((Handler (JobStatus 'Safe JobLog)
                                                              :<|> ((JobInput Maybe PostNode
                                                                     -> Handler
                                                                          (JobStatus 'Safe JobLog))
                                                                    :<|> (ID 'Unsafe "job"
                                                                          -> (Maybe Limit
                                                                              -> Maybe Offset
                                                                              -> Handler
                                                                                   (JobStatus
                                                                                      'Safe JobLog))
                                                                             :<|> ((Maybe Limit
                                                                                    -> Maybe Offset
                                                                                    -> Handler
                                                                                         (JobStatus
                                                                                            'Safe
                                                                                            JobLog))
                                                                                   :<|> Handler
                                                                                          (JobOutput
                                                                                             JobLog)))))
                                                             :<|> ((Handler (JobStatus 'Safe JobLog)
                                                                    :<|> ((JobInput
                                                                             Maybe FrameCalcUpload
                                                                           -> Handler
                                                                                (JobStatus
                                                                                   'Safe JobLog))
                                                                          :<|> (ID 'Unsafe "job"
                                                                                -> (Maybe Limit
                                                                                    -> Maybe Offset
                                                                                    -> Handler
                                                                                         (JobStatus
                                                                                            'Safe
                                                                                            JobLog))
                                                                                   :<|> ((Maybe
                                                                                            Limit
                                                                                          -> Maybe
                                                                                               Offset
                                                                                          -> Handler
                                                                                               (JobStatus
                                                                                                  'Safe
                                                                                                  JobLog))
                                                                                         :<|> Handler
                                                                                                (JobOutput
                                                                                                   JobLog)))))
                                                                   :<|> ((HyperdataCorpus
                                                                          -> Handler Int)
                                                                         :<|> ((Handler
                                                                                  (JobStatus
                                                                                     'Safe JobLog)
                                                                                :<|> ((JobInput
                                                                                         Maybe
                                                                                         UpdateNodeParams
                                                                                       -> Handler
                                                                                            (JobStatus
                                                                                               'Safe
                                                                                               JobLog))
                                                                                      :<|> (ID
                                                                                              'Unsafe
                                                                                              "job"
                                                                                            -> (Maybe
                                                                                                  Limit
                                                                                                -> Maybe
                                                                                                     Offset
                                                                                                -> Handler
                                                                                                     (JobStatus
                                                                                                        'Safe
                                                                                                        JobLog))
                                                                                               :<|> ((Maybe
                                                                                                        Limit
                                                                                                      -> Maybe
                                                                                                           Offset
                                                                                                      -> Handler
                                                                                                           (JobStatus
                                                                                                              'Safe
                                                                                                              JobLog))
                                                                                                     :<|> Handler
                                                                                                            (JobOutput
                                                                                                               JobLog)))))
                                                                               :<|> (Handler Int
                                                                                     :<|> ((Maybe
                                                                                              NodeType
                                                                                            -> Maybe
                                                                                                 Int
                                                                                            -> Maybe
                                                                                                 Int
                                                                                            -> Handler
                                                                                                 (TableResult
                                                                                                    (NodePoly
                                                                                                       NodeId
                                                                                                       (Maybe
                                                                                                          Text)
                                                                                                       Int
                                                                                                       Int
                                                                                                       (Maybe
                                                                                                          NodeId)
                                                                                                       Text
                                                                                                       UTCTime
                                                                                                       HyperdataCorpus)))
                                                                                           :<|> (((Maybe
                                                                                                     TabType
                                                                                                   -> Maybe
                                                                                                        NodeId
                                                                                                   -> Maybe
                                                                                                        Int
                                                                                                   -> Maybe
                                                                                                        Int
                                                                                                   -> Maybe
                                                                                                        OrderBy
                                                                                                   -> Maybe
                                                                                                        Text
                                                                                                   -> Handler
                                                                                                        (HashedResponse
                                                                                                           FacetTableResult))
                                                                                                  :<|> ((TableQuery
                                                                                                         -> Handler
                                                                                                              FacetTableResult)
                                                                                                        :<|> (Maybe
                                                                                                                TabType
                                                                                                              -> Handler
                                                                                                                   Text)))
                                                                                                 :<|> (((TabType
                                                                                                         -> NodeId
                                                                                                         -> Int
                                                                                                         -> Maybe
                                                                                                              Int
                                                                                                         -> Maybe
                                                                                                              ListType
                                                                                                         -> Maybe
                                                                                                              Int
                                                                                                         -> Maybe
                                                                                                              Int
                                                                                                         -> Maybe
                                                                                                              OrderBy
                                                                                                         -> Maybe
                                                                                                              Text
                                                                                                         -> Handler
                                                                                                              (VersionedWithCount
                                                                                                                 NgramsTable))
                                                                                                        :<|> ((TabType
                                                                                                               -> NodeId
                                                                                                               -> Versioned
                                                                                                                    NgramsTablePatch
                                                                                                               -> Handler
                                                                                                                    (Versioned
                                                                                                                       NgramsTablePatch))
                                                                                                              :<|> ((TabType
                                                                                                                     -> NodeId
                                                                                                                     -> Handler
                                                                                                                          Int)
                                                                                                                    :<|> ((TabType
                                                                                                                           -> NodeId
                                                                                                                           -> Handler
                                                                                                                                Int)
                                                                                                                          :<|> (Handler
                                                                                                                                  (JobStatus
                                                                                                                                     'Safe
                                                                                                                                     JobLog)
                                                                                                                                :<|> ((JobInput
                                                                                                                                         Maybe
                                                                                                                                         UpdateTableNgramsCharts
                                                                                                                                       -> Handler
                                                                                                                                            (JobStatus
                                                                                                                                               'Safe
                                                                                                                                               JobLog))
                                                                                                                                      :<|> (ID
                                                                                                                                              'Unsafe
                                                                                                                                              "job"
                                                                                                                                            -> (Maybe
                                                                                                                                                  Limit
                                                                                                                                                -> Maybe
                                                                                                                                                     Offset
                                                                                                                                                -> Handler
                                                                                                                                                     (JobStatus
                                                                                                                                                        'Safe
                                                                                                                                                        JobLog))
                                                                                                                                               :<|> ((Maybe
                                                                                                                                                        Limit
                                                                                                                                                      -> Maybe
                                                                                                                                                           Offset
                                                                                                                                                      -> Handler
                                                                                                                                                           (JobStatus
                                                                                                                                                              'Safe
                                                                                                                                                              JobLog))
                                                                                                                                                     :<|> Handler
                                                                                                                                                            (JobOutput
                                                                                                                                                               JobLog)))))))))
                                                                                                       :<|> ((NodesToCategory
                                                                                                              -> Handler
                                                                                                                   [Int])
                                                                                                             :<|> ((NodesToScore
                                                                                                                    -> Handler
                                                                                                                         [Int])
                                                                                                                   :<|> ((SearchQuery
                                                                                                                          -> Maybe
                                                                                                                               Int
                                                                                                                          -> Maybe
                                                                                                                               Int
                                                                                                                          -> Maybe
                                                                                                                               OrderBy
                                                                                                                          -> Handler
                                                                                                                               SearchResult)
                                                                                                                         :<|> ((ShareNodeParams
                                                                                                                                -> Handler
                                                                                                                                     Int)
                                                                                                                               :<|> ((NodeId
                                                                                                                                      -> Maybe
                                                                                                                                           NodeId
                                                                                                                                      -> Handler
                                                                                                                                           Int)
                                                                                                                                     :<|> (Handler
                                                                                                                                             [NodeId]
                                                                                                                                           :<|> ((Maybe
                                                                                                                                                    TabType
                                                                                                                                                  -> Maybe
                                                                                                                                                       Int
                                                                                                                                                  -> Maybe
                                                                                                                                                       Int
                                                                                                                                                  -> Maybe
                                                                                                                                                       OrderBy
                                                                                                                                                  -> Handler
                                                                                                                                                       [FacetDoc])
                                                                                                                                                 :<|> (((Maybe
                                                                                                                                                           NodeId
                                                                                                                                                         -> TabType
                                                                                                                                                         -> Maybe
                                                                                                                                                              Int
                                                                                                                                                         -> Handler
                                                                                                                                                              (HashedResponse
                                                                                                                                                                 Metrics))
                                                                                                                                                        :<|> ((Maybe
                                                                                                                                                                 NodeId
                                                                                                                                                               -> TabType
                                                                                                                                                               -> Maybe
                                                                                                                                                                    Int
                                                                                                                                                               -> Handler
                                                                                                                                                                    ())
                                                                                                                                                              :<|> (Maybe
                                                                                                                                                                      NodeId
                                                                                                                                                                    -> TabType
                                                                                                                                                                    -> Handler
                                                                                                                                                                         Text)))
                                                                                                                                                       :<|> (((Maybe
                                                                                                                                                                 UTCTime
                                                                                                                                                               -> Maybe
                                                                                                                                                                    UTCTime
                                                                                                                                                               -> Maybe
                                                                                                                                                                    NodeId
                                                                                                                                                               -> TabType
                                                                                                                                                               -> Handler
                                                                                                                                                                    (HashedResponse
                                                                                                                                                                       (ChartMetrics
                                                                                                                                                                          Histo)))
                                                                                                                                                              :<|> ((Maybe
                                                                                                                                                                       NodeId
                                                                                                                                                                     -> TabType
                                                                                                                                                                     -> Maybe
                                                                                                                                                                          Int
                                                                                                                                                                     -> Handler
                                                                                                                                                                          ())
                                                                                                                                                                    :<|> (Maybe
                                                                                                                                                                            NodeId
                                                                                                                                                                          -> TabType
                                                                                                                                                                          -> Handler
                                                                                                                                                                               Text)))
                                                                                                                                                             :<|> (((Maybe
                                                                                                                                                                       UTCTime
                                                                                                                                                                     -> Maybe
                                                                                                                                                                          UTCTime
                                                                                                                                                                     -> Maybe
                                                                                                                                                                          NodeId
                                                                                                                                                                     -> TabType
                                                                                                                                                                     -> Handler
                                                                                                                                                                          (HashedResponse
                                                                                                                                                                             (ChartMetrics
                                                                                                                                                                                Histo)))
                                                                                                                                                                    :<|> ((Maybe
                                                                                                                                                                             NodeId
                                                                                                                                                                           -> TabType
                                                                                                                                                                           -> Maybe
                                                                                                                                                                                Int
                                                                                                                                                                           -> Handler
                                                                                                                                                                                ())
                                                                                                                                                                          :<|> (Maybe
                                                                                                                                                                                  NodeId
                                                                                                                                                                                -> TabType
                                                                                                                                                                                -> Handler
                                                                                                                                                                                     Text)))
                                                                                                                                                                   :<|> (((Maybe
                                                                                                                                                                             UTCTime
                                                                                                                                                                           -> Maybe
                                                                                                                                                                                UTCTime
                                                                                                                                                                           -> Maybe
                                                                                                                                                                                NodeId
                                                                                                                                                                           -> TabType
                                                                                                                                                                           -> ListType
                                                                                                                                                                           -> Handler
                                                                                                                                                                                (HashedResponse
                                                                                                                                                                                   (ChartMetrics
                                                                                                                                                                                      (Vector
                                                                                                                                                                                         NgramsTree))))
                                                                                                                                                                          :<|> ((Maybe
                                                                                                                                                                                   NodeId
                                                                                                                                                                                 -> TabType
                                                                                                                                                                                 -> ListType
                                                                                                                                                                                 -> Handler
                                                                                                                                                                                      ())
                                                                                                                                                                                :<|> (Maybe
                                                                                                                                                                                        NodeId
                                                                                                                                                                                      -> TabType
                                                                                                                                                                                      -> ListType
                                                                                                                                                                                      -> Handler
                                                                                                                                                                                           Text)))
                                                                                                                                                                         :<|> (((Maybe
                                                                                                                                                                                   NodeId
                                                                                                                                                                                 -> Maybe
                                                                                                                                                                                      Int
                                                                                                                                                                                 -> Maybe
                                                                                                                                                                                      Int
                                                                                                                                                                                 -> Handler
                                                                                                                                                                                      SVG)
                                                                                                                                                                                :<|> (Maybe
                                                                                                                                                                                        NodeId
                                                                                                                                                                                      -> Handler
                                                                                                                                                                                           NodeId))
                                                                                                                                                                               :<|> ((NodeId
                                                                                                                                                                                      -> Handler
                                                                                                                                                                                           [Int])
                                                                                                                                                                                     :<|> ((NodeId
                                                                                                                                                                                            -> Handler
                                                                                                                                                                                                 Int)
                                                                                                                                                                                           :<|> (Handler
                                                                                                                                                                                                   (Headers
                                                                                                                                                                                                      '[Header
                                                                                                                                                                                                          "Content-Type"
                                                                                                                                                                                                          Text]
                                                                                                                                                                                                      BSResponse)
                                                                                                                                                                                                 :<|> ((Handler
                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                             JobLog)
                                                                                                                                                                                                        :<|> ((JobInput
                                                                                                                                                                                                                 Maybe
                                                                                                                                                                                                                 NewWithFile
                                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                                       JobLog))
                                                                                                                                                                                                              :<|> (ID
                                                                                                                                                                                                                      'Unsafe
                                                                                                                                                                                                                      "job"
                                                                                                                                                                                                                    -> (Maybe
                                                                                                                                                                                                                          Limit
                                                                                                                                                                                                                        -> Maybe
                                                                                                                                                                                                                             Offset
                                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                                             (JobStatus
                                                                                                                                                                                                                                'Safe
                                                                                                                                                                                                                                JobLog))
                                                                                                                                                                                                                       :<|> ((Maybe
                                                                                                                                                                                                                                Limit
                                                                                                                                                                                                                              -> Maybe
                                                                                                                                                                                                                                   Offset
                                                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                                                   (JobStatus
                                                                                                                                                                                                                                      'Safe
                                                                                                                                                                                                                                      JobLog))
                                                                                                                                                                                                                             :<|> Handler
                                                                                                                                                                                                                                    (JobOutput
                                                                                                                                                                                                                                       JobLog)))))
                                                                                                                                                                                                       :<|> ((Handler
                                                                                                                                                                                                                (JobStatus
                                                                                                                                                                                                                   'Safe
                                                                                                                                                                                                                   JobLog)
                                                                                                                                                                                                              :<|> ((JobInput
                                                                                                                                                                                                                       Maybe
                                                                                                                                                                                                                       Params
                                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                                             JobLog))
                                                                                                                                                                                                                    :<|> (ID
                                                                                                                                                                                                                            'Unsafe
                                                                                                                                                                                                                            "job"
                                                                                                                                                                                                                          -> (Maybe
                                                                                                                                                                                                                                Limit
                                                                                                                                                                                                                              -> Maybe
                                                                                                                                                                                                                                   Offset
                                                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                                                   (JobStatus
                                                                                                                                                                                                                                      'Safe
                                                                                                                                                                                                                                      JobLog))
                                                                                                                                                                                                                             :<|> ((Maybe
                                                                                                                                                                                                                                      Limit
                                                                                                                                                                                                                                    -> Maybe
                                                                                                                                                                                                                                         Offset
                                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                                   :<|> Handler
                                                                                                                                                                                                                                          (JobOutput
                                                                                                                                                                                                                                             JobLog)))))
                                                                                                                                                                                                             :<|> (Handler
                                                                                                                                                                                                                     (JobStatus
                                                                                                                                                                                                                        'Safe
                                                                                                                                                                                                                        JobLog)
                                                                                                                                                                                                                   :<|> ((JobInput
                                                                                                                                                                                                                            Maybe
                                                                                                                                                                                                                            DocumentUpload
                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                         :<|> (ID
                                                                                                                                                                                                                                 'Unsafe
                                                                                                                                                                                                                                 "job"
                                                                                                                                                                                                                               -> (Maybe
                                                                                                                                                                                                                                     Limit
                                                                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                                                                        Offset
                                                                                                                                                                                                                                   -> Handler
                                                                                                                                                                                                                                        (JobStatus
                                                                                                                                                                                                                                           'Safe
                                                                                                                                                                                                                                           JobLog))
                                                                                                                                                                                                                                  :<|> ((Maybe
                                                                                                                                                                                                                                           Limit
                                                                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                                                                              Offset
                                                                                                                                                                                                                                         -> Handler
                                                                                                                                                                                                                                              (JobStatus
                                                                                                                                                                                                                                                 'Safe
                                                                                                                                                                                                                                                 JobLog))
                                                                                                                                                                                                                                        :<|> Handler
                                                                                                                                                                                                                                               (JobOutput
                                                                                                                                                                                                                                                  JobLog)))))))))))))))))))))))))))))))))
                                       :<|> ((NodeId
                                              -> NodeId
                                              -> Handler
                                                   (NodePoly
                                                      NodeId
                                                      (Maybe Text)
                                                      Int
                                                      Int
                                                      (Maybe NodeId)
                                                      Text
                                                      UTCTime
                                                      HyperdataAny))
                                             :<|> ((NodeId
                                                    -> Maybe NodeId
                                                    -> Maybe NgramsType
                                                    -> Handler Corpus)
                                                   :<|> ((NodeId
                                                          -> Handler
                                                               (NodePoly
                                                                  NodeId
                                                                  (Maybe Text)
                                                                  Int
                                                                  Int
                                                                  (Maybe NodeId)
                                                                  Text
                                                                  UTCTime
                                                                  HyperdataAnnuaire)
                                                             :<|> ((RenameNode -> Handler [Int])
                                                                   :<|> ((PostNode
                                                                          -> Handler [NodeId])
                                                                         :<|> ((Handler
                                                                                  (JobStatus
                                                                                     'Safe JobLog)
                                                                                :<|> ((JobInput
                                                                                         Maybe
                                                                                         PostNode
                                                                                       -> Handler
                                                                                            (JobStatus
                                                                                               'Safe
                                                                                               JobLog))
                                                                                      :<|> (ID
                                                                                              'Unsafe
                                                                                              "job"
                                                                                            -> (Maybe
                                                                                                  Limit
                                                                                                -> Maybe
                                                                                                     Offset
                                                                                                -> Handler
                                                                                                     (JobStatus
                                                                                                        'Safe
                                                                                                        JobLog))
                                                                                               :<|> ((Maybe
                                                                                                        Limit
                                                                                                      -> Maybe
                                                                                                           Offset
                                                                                                      -> Handler
                                                                                                           (JobStatus
                                                                                                              'Safe
                                                                                                              JobLog))
                                                                                                     :<|> Handler
                                                                                                            (JobOutput
                                                                                                               JobLog)))))
                                                                               :<|> ((Handler
                                                                                        (JobStatus
                                                                                           'Safe
                                                                                           JobLog)
                                                                                      :<|> ((JobInput
                                                                                               Maybe
                                                                                               FrameCalcUpload
                                                                                             -> Handler
                                                                                                  (JobStatus
                                                                                                     'Safe
                                                                                                     JobLog))
                                                                                            :<|> (ID
                                                                                                    'Unsafe
                                                                                                    "job"
                                                                                                  -> (Maybe
                                                                                                        Limit
                                                                                                      -> Maybe
                                                                                                           Offset
                                                                                                      -> Handler
                                                                                                           (JobStatus
                                                                                                              'Safe
                                                                                                              JobLog))
                                                                                                     :<|> ((Maybe
                                                                                                              Limit
                                                                                                            -> Maybe
                                                                                                                 Offset
                                                                                                            -> Handler
                                                                                                                 (JobStatus
                                                                                                                    'Safe
                                                                                                                    JobLog))
                                                                                                           :<|> Handler
                                                                                                                  (JobOutput
                                                                                                                     JobLog)))))
                                                                                     :<|> ((HyperdataAnnuaire
                                                                                            -> Handler
                                                                                                 Int)
                                                                                           :<|> ((Handler
                                                                                                    (JobStatus
                                                                                                       'Safe
                                                                                                       JobLog)
                                                                                                  :<|> ((JobInput
                                                                                                           Maybe
                                                                                                           UpdateNodeParams
                                                                                                         -> Handler
                                                                                                              (JobStatus
                                                                                                                 'Safe
                                                                                                                 JobLog))
                                                                                                        :<|> (ID
                                                                                                                'Unsafe
                                                                                                                "job"
                                                                                                              -> (Maybe
                                                                                                                    Limit
                                                                                                                  -> Maybe
                                                                                                                       Offset
                                                                                                                  -> Handler
                                                                                                                       (JobStatus
                                                                                                                          'Safe
                                                                                                                          JobLog))
                                                                                                                 :<|> ((Maybe
                                                                                                                          Limit
                                                                                                                        -> Maybe
                                                                                                                             Offset
                                                                                                                        -> Handler
                                                                                                                             (JobStatus
                                                                                                                                'Safe
                                                                                                                                JobLog))
                                                                                                                       :<|> Handler
                                                                                                                              (JobOutput
                                                                                                                                 JobLog)))))
                                                                                                 :<|> (Handler
                                                                                                         Int
                                                                                                       :<|> ((Maybe
                                                                                                                NodeType
                                                                                                              -> Maybe
                                                                                                                   Int
                                                                                                              -> Maybe
                                                                                                                   Int
                                                                                                              -> Handler
                                                                                                                   (TableResult
                                                                                                                      (NodePoly
                                                                                                                         NodeId
                                                                                                                         (Maybe
                                                                                                                            Text)
                                                                                                                         Int
                                                                                                                         Int
                                                                                                                         (Maybe
                                                                                                                            NodeId)
                                                                                                                         Text
                                                                                                                         UTCTime
                                                                                                                         HyperdataAnnuaire)))
                                                                                                             :<|> (((Maybe
                                                                                                                       TabType
                                                                                                                     -> Maybe
                                                                                                                          NodeId
                                                                                                                     -> Maybe
                                                                                                                          Int
                                                                                                                     -> Maybe
                                                                                                                          Int
                                                                                                                     -> Maybe
                                                                                                                          OrderBy
                                                                                                                     -> Maybe
                                                                                                                          Text
                                                                                                                     -> Handler
                                                                                                                          (HashedResponse
                                                                                                                             FacetTableResult))
                                                                                                                    :<|> ((TableQuery
                                                                                                                           -> Handler
                                                                                                                                FacetTableResult)
                                                                                                                          :<|> (Maybe
                                                                                                                                  TabType
                                                                                                                                -> Handler
                                                                                                                                     Text)))
                                                                                                                   :<|> (((TabType
                                                                                                                           -> NodeId
                                                                                                                           -> Int
                                                                                                                           -> Maybe
                                                                                                                                Int
                                                                                                                           -> Maybe
                                                                                                                                ListType
                                                                                                                           -> Maybe
                                                                                                                                Int
                                                                                                                           -> Maybe
                                                                                                                                Int
                                                                                                                           -> Maybe
                                                                                                                                OrderBy
                                                                                                                           -> Maybe
                                                                                                                                Text
                                                                                                                           -> Handler
                                                                                                                                (VersionedWithCount
                                                                                                                                   NgramsTable))
                                                                                                                          :<|> ((TabType
                                                                                                                                 -> NodeId
                                                                                                                                 -> Versioned
                                                                                                                                      NgramsTablePatch
                                                                                                                                 -> Handler
                                                                                                                                      (Versioned
                                                                                                                                         NgramsTablePatch))
                                                                                                                                :<|> ((TabType
                                                                                                                                       -> NodeId
                                                                                                                                       -> Handler
                                                                                                                                            Int)
                                                                                                                                      :<|> ((TabType
                                                                                                                                             -> NodeId
                                                                                                                                             -> Handler
                                                                                                                                                  Int)
                                                                                                                                            :<|> (Handler
                                                                                                                                                    (JobStatus
                                                                                                                                                       'Safe
                                                                                                                                                       JobLog)
                                                                                                                                                  :<|> ((JobInput
                                                                                                                                                           Maybe
                                                                                                                                                           UpdateTableNgramsCharts
                                                                                                                                                         -> Handler
                                                                                                                                                              (JobStatus
                                                                                                                                                                 'Safe
                                                                                                                                                                 JobLog))
                                                                                                                                                        :<|> (ID
                                                                                                                                                                'Unsafe
                                                                                                                                                                "job"
                                                                                                                                                              -> (Maybe
                                                                                                                                                                    Limit
                                                                                                                                                                  -> Maybe
                                                                                                                                                                       Offset
                                                                                                                                                                  -> Handler
                                                                                                                                                                       (JobStatus
                                                                                                                                                                          'Safe
                                                                                                                                                                          JobLog))
                                                                                                                                                                 :<|> ((Maybe
                                                                                                                                                                          Limit
                                                                                                                                                                        -> Maybe
                                                                                                                                                                             Offset
                                                                                                                                                                        -> Handler
                                                                                                                                                                             (JobStatus
                                                                                                                                                                                'Safe
                                                                                                                                                                                JobLog))
                                                                                                                                                                       :<|> Handler
                                                                                                                                                                              (JobOutput
                                                                                                                                                                                 JobLog)))))))))
                                                                                                                         :<|> ((NodesToCategory
                                                                                                                                -> Handler
                                                                                                                                     [Int])
                                                                                                                               :<|> ((NodesToScore
                                                                                                                                      -> Handler
                                                                                                                                           [Int])
                                                                                                                                     :<|> ((SearchQuery
                                                                                                                                            -> Maybe
                                                                                                                                                 Int
                                                                                                                                            -> Maybe
                                                                                                                                                 Int
                                                                                                                                            -> Maybe
                                                                                                                                                 OrderBy
                                                                                                                                            -> Handler
                                                                                                                                                 SearchResult)
                                                                                                                                           :<|> ((ShareNodeParams
                                                                                                                                                  -> Handler
                                                                                                                                                       Int)
                                                                                                                                                 :<|> ((NodeId
                                                                                                                                                        -> Maybe
                                                                                                                                                             NodeId
                                                                                                                                                        -> Handler
                                                                                                                                                             Int)
                                                                                                                                                       :<|> (Handler
                                                                                                                                                               [NodeId]
                                                                                                                                                             :<|> ((Maybe
                                                                                                                                                                      TabType
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         Int
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         Int
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         OrderBy
                                                                                                                                                                    -> Handler
                                                                                                                                                                         [FacetDoc])
                                                                                                                                                                   :<|> (((Maybe
                                                                                                                                                                             NodeId
                                                                                                                                                                           -> TabType
                                                                                                                                                                           -> Maybe
                                                                                                                                                                                Int
                                                                                                                                                                           -> Handler
                                                                                                                                                                                (HashedResponse
                                                                                                                                                                                   Metrics))
                                                                                                                                                                          :<|> ((Maybe
                                                                                                                                                                                   NodeId
                                                                                                                                                                                 -> TabType
                                                                                                                                                                                 -> Maybe
                                                                                                                                                                                      Int
                                                                                                                                                                                 -> Handler
                                                                                                                                                                                      ())
                                                                                                                                                                                :<|> (Maybe
                                                                                                                                                                                        NodeId
                                                                                                                                                                                      -> TabType
                                                                                                                                                                                      -> Handler
                                                                                                                                                                                           Text)))
                                                                                                                                                                         :<|> (((Maybe
                                                                                                                                                                                   UTCTime
                                                                                                                                                                                 -> Maybe
                                                                                                                                                                                      UTCTime
                                                                                                                                                                                 -> Maybe
                                                                                                                                                                                      NodeId
                                                                                                                                                                                 -> TabType
                                                                                                                                                                                 -> Handler
                                                                                                                                                                                      (HashedResponse
                                                                                                                                                                                         (ChartMetrics
                                                                                                                                                                                            Histo)))
                                                                                                                                                                                :<|> ((Maybe
                                                                                                                                                                                         NodeId
                                                                                                                                                                                       -> TabType
                                                                                                                                                                                       -> Maybe
                                                                                                                                                                                            Int
                                                                                                                                                                                       -> Handler
                                                                                                                                                                                            ())
                                                                                                                                                                                      :<|> (Maybe
                                                                                                                                                                                              NodeId
                                                                                                                                                                                            -> TabType
                                                                                                                                                                                            -> Handler
                                                                                                                                                                                                 Text)))
                                                                                                                                                                               :<|> (((Maybe
                                                                                                                                                                                         UTCTime
                                                                                                                                                                                       -> Maybe
                                                                                                                                                                                            UTCTime
                                                                                                                                                                                       -> Maybe
                                                                                                                                                                                            NodeId
                                                                                                                                                                                       -> TabType
                                                                                                                                                                                       -> Handler
                                                                                                                                                                                            (HashedResponse
                                                                                                                                                                                               (ChartMetrics
                                                                                                                                                                                                  Histo)))
                                                                                                                                                                                      :<|> ((Maybe
                                                                                                                                                                                               NodeId
                                                                                                                                                                                             -> TabType
                                                                                                                                                                                             -> Maybe
                                                                                                                                                                                                  Int
                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                  ())
                                                                                                                                                                                            :<|> (Maybe
                                                                                                                                                                                                    NodeId
                                                                                                                                                                                                  -> TabType
                                                                                                                                                                                                  -> Handler
                                                                                                                                                                                                       Text)))
                                                                                                                                                                                     :<|> (((Maybe
                                                                                                                                                                                               UTCTime
                                                                                                                                                                                             -> Maybe
                                                                                                                                                                                                  UTCTime
                                                                                                                                                                                             -> Maybe
                                                                                                                                                                                                  NodeId
                                                                                                                                                                                             -> TabType
                                                                                                                                                                                             -> ListType
                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                  (HashedResponse
                                                                                                                                                                                                     (ChartMetrics
                                                                                                                                                                                                        (Vector
                                                                                                                                                                                                           NgramsTree))))
                                                                                                                                                                                            :<|> ((Maybe
                                                                                                                                                                                                     NodeId
                                                                                                                                                                                                   -> TabType
                                                                                                                                                                                                   -> ListType
                                                                                                                                                                                                   -> Handler
                                                                                                                                                                                                        ())
                                                                                                                                                                                                  :<|> (Maybe
                                                                                                                                                                                                          NodeId
                                                                                                                                                                                                        -> TabType
                                                                                                                                                                                                        -> ListType
                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                             Text)))
                                                                                                                                                                                           :<|> (((Maybe
                                                                                                                                                                                                     NodeId
                                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                                        Int
                                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                                        Int
                                                                                                                                                                                                   -> Handler
                                                                                                                                                                                                        SVG)
                                                                                                                                                                                                  :<|> (Maybe
                                                                                                                                                                                                          NodeId
                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                             NodeId))
                                                                                                                                                                                                 :<|> ((NodeId
                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                             [Int])
                                                                                                                                                                                                       :<|> ((NodeId
                                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                                   Int)
                                                                                                                                                                                                             :<|> (Handler
                                                                                                                                                                                                                     (Headers
                                                                                                                                                                                                                        '[Header
                                                                                                                                                                                                                            "Content-Type"
                                                                                                                                                                                                                            Text]
                                                                                                                                                                                                                        BSResponse)
                                                                                                                                                                                                                   :<|> ((Handler
                                                                                                                                                                                                                            (JobStatus
                                                                                                                                                                                                                               'Safe
                                                                                                                                                                                                                               JobLog)
                                                                                                                                                                                                                          :<|> ((JobInput
                                                                                                                                                                                                                                   Maybe
                                                                                                                                                                                                                                   NewWithFile
                                                                                                                                                                                                                                 -> Handler
                                                                                                                                                                                                                                      (JobStatus
                                                                                                                                                                                                                                         'Safe
                                                                                                                                                                                                                                         JobLog))
                                                                                                                                                                                                                                :<|> (ID
                                                                                                                                                                                                                                        'Unsafe
                                                                                                                                                                                                                                        "job"
                                                                                                                                                                                                                                      -> (Maybe
                                                                                                                                                                                                                                            Limit
                                                                                                                                                                                                                                          -> Maybe
                                                                                                                                                                                                                                               Offset
                                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                                         :<|> ((Maybe
                                                                                                                                                                                                                                                  Limit
                                                                                                                                                                                                                                                -> Maybe
                                                                                                                                                                                                                                                     Offset
                                                                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                                                                     (JobStatus
                                                                                                                                                                                                                                                        'Safe
                                                                                                                                                                                                                                                        JobLog))
                                                                                                                                                                                                                                               :<|> Handler
                                                                                                                                                                                                                                                      (JobOutput
                                                                                                                                                                                                                                                         JobLog)))))
                                                                                                                                                                                                                         :<|> ((Handler
                                                                                                                                                                                                                                  (JobStatus
                                                                                                                                                                                                                                     'Safe
                                                                                                                                                                                                                                     JobLog)
                                                                                                                                                                                                                                :<|> ((JobInput
                                                                                                                                                                                                                                         Maybe
                                                                                                                                                                                                                                         Params
                                                                                                                                                                                                                                       -> Handler
                                                                                                                                                                                                                                            (JobStatus
                                                                                                                                                                                                                                               'Safe
                                                                                                                                                                                                                                               JobLog))
                                                                                                                                                                                                                                      :<|> (ID
                                                                                                                                                                                                                                              'Unsafe
                                                                                                                                                                                                                                              "job"
                                                                                                                                                                                                                                            -> (Maybe
                                                                                                                                                                                                                                                  Limit
                                                                                                                                                                                                                                                -> Maybe
                                                                                                                                                                                                                                                     Offset
                                                                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                                                                     (JobStatus
                                                                                                                                                                                                                                                        'Safe
                                                                                                                                                                                                                                                        JobLog))
                                                                                                                                                                                                                                               :<|> ((Maybe
                                                                                                                                                                                                                                                        Limit
                                                                                                                                                                                                                                                      -> Maybe
                                                                                                                                                                                                                                                           Offset
                                                                                                                                                                                                                                                      -> Handler
                                                                                                                                                                                                                                                           (JobStatus
                                                                                                                                                                                                                                                              'Safe
                                                                                                                                                                                                                                                              JobLog))
                                                                                                                                                                                                                                                     :<|> Handler
                                                                                                                                                                                                                                                            (JobOutput
                                                                                                                                                                                                                                                               JobLog)))))
                                                                                                                                                                                                                               :<|> (Handler
                                                                                                                                                                                                                                       (JobStatus
                                                                                                                                                                                                                                          'Safe
                                                                                                                                                                                                                                          JobLog)
                                                                                                                                                                                                                                     :<|> ((JobInput
                                                                                                                                                                                                                                              Maybe
                                                                                                                                                                                                                                              DocumentUpload
                                                                                                                                                                                                                                            -> Handler
                                                                                                                                                                                                                                                 (JobStatus
                                                                                                                                                                                                                                                    'Safe
                                                                                                                                                                                                                                                    JobLog))
                                                                                                                                                                                                                                           :<|> (ID
                                                                                                                                                                                                                                                   'Unsafe
                                                                                                                                                                                                                                                   "job"
                                                                                                                                                                                                                                                 -> (Maybe
                                                                                                                                                                                                                                                       Limit
                                                                                                                                                                                                                                                     -> Maybe
                                                                                                                                                                                                                                                          Offset
                                                                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                                                                             JobLog))
                                                                                                                                                                                                                                                    :<|> ((Maybe
                                                                                                                                                                                                                                                             Limit
                                                                                                                                                                                                                                                           -> Maybe
                                                                                                                                                                                                                                                                Offset
                                                                                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                                                                                (JobStatus
                                                                                                                                                                                                                                                                   'Safe
                                                                                                                                                                                                                                                                   JobLog))
                                                                                                                                                                                                                                                          :<|> Handler
                                                                                                                                                                                                                                                                 (JobOutput
                                                                                                                                                                                                                                                                    JobLog)))))))))))))))))))))))))))))))))
                                                         :<|> ((NodeId
                                                                -> (Handler (JobStatus 'Safe JobLog)
                                                                    :<|> ((JobInput
                                                                             Maybe AddContactParams
                                                                           -> Handler
                                                                                (JobStatus
                                                                                   'Safe JobLog))
                                                                          :<|> (ID 'Unsafe "job"
                                                                                -> (Maybe Limit
                                                                                    -> Maybe Offset
                                                                                    -> Handler
                                                                                         (JobStatus
                                                                                            'Safe
                                                                                            JobLog))
                                                                                   :<|> ((Maybe
                                                                                            Limit
                                                                                          -> Maybe
                                                                                               Offset
                                                                                          -> Handler
                                                                                               (JobStatus
                                                                                                  'Safe
                                                                                                  JobLog))
                                                                                         :<|> Handler
                                                                                                (JobOutput
                                                                                                   JobLog)))))
                                                                   :<|> (NodeId
                                                                         -> Handler
                                                                              (NodePoly
                                                                                 NodeId
                                                                                 (Maybe Text)
                                                                                 Int
                                                                                 Int
                                                                                 (Maybe NodeId)
                                                                                 Text
                                                                                 UTCTime
                                                                                 HyperdataContact)))
                                                               :<|> ((NodeId
                                                                      -> (TabType
                                                                          -> NodeId
                                                                          -> Int
                                                                          -> Maybe Int
                                                                          -> Maybe ListType
                                                                          -> Maybe Int
                                                                          -> Maybe Int
                                                                          -> Maybe OrderBy
                                                                          -> Maybe Text
                                                                          -> Handler
                                                                               (VersionedWithCount
                                                                                  NgramsTable))
                                                                         :<|> ((TabType
                                                                                -> NodeId
                                                                                -> Versioned
                                                                                     NgramsTablePatch
                                                                                -> Handler
                                                                                     (Versioned
                                                                                        NgramsTablePatch))
                                                                               :<|> ((TabType
                                                                                      -> NodeId
                                                                                      -> Handler
                                                                                           Int)
                                                                                     :<|> ((TabType
                                                                                            -> NodeId
                                                                                            -> Handler
                                                                                                 Int)
                                                                                           :<|> (Handler
                                                                                                   (JobStatus
                                                                                                      'Safe
                                                                                                      JobLog)
                                                                                                 :<|> ((JobInput
                                                                                                          Maybe
                                                                                                          UpdateTableNgramsCharts
                                                                                                        -> Handler
                                                                                                             (JobStatus
                                                                                                                'Safe
                                                                                                                JobLog))
                                                                                                       :<|> (ID
                                                                                                               'Unsafe
                                                                                                               "job"
                                                                                                             -> (Maybe
                                                                                                                   Limit
                                                                                                                 -> Maybe
                                                                                                                      Offset
                                                                                                                 -> Handler
                                                                                                                      (JobStatus
                                                                                                                         'Safe
                                                                                                                         JobLog))
                                                                                                                :<|> ((Maybe
                                                                                                                         Limit
                                                                                                                       -> Maybe
                                                                                                                            Offset
                                                                                                                       -> Handler
                                                                                                                            (JobStatus
                                                                                                                               'Safe
                                                                                                                               JobLog))
                                                                                                                      :<|> Handler
                                                                                                                             (JobOutput
                                                                                                                                JobLog)))))))))
                                                                     :<|> ((Query -> Handler Counts)
                                                                           :<|> ((NodeId
                                                                                  -> Handler
                                                                                       HyperdataGraphAPI
                                                                                     :<|> ((Handler
                                                                                              (JobStatus
                                                                                                 'Safe
                                                                                                 JobLog)
                                                                                            :<|> ((JobInput
                                                                                                     Maybe
                                                                                                     ()
                                                                                                   -> Handler
                                                                                                        (JobStatus
                                                                                                           'Safe
                                                                                                           JobLog))
                                                                                                  :<|> (ID
                                                                                                          'Unsafe
                                                                                                          "job"
                                                                                                        -> (Maybe
                                                                                                              Limit
                                                                                                            -> Maybe
                                                                                                                 Offset
                                                                                                            -> Handler
                                                                                                                 (JobStatus
                                                                                                                    'Safe
                                                                                                                    JobLog))
                                                                                                           :<|> ((Maybe
                                                                                                                    Limit
                                                                                                                  -> Maybe
                                                                                                                       Offset
                                                                                                                  -> Handler
                                                                                                                       (JobStatus
                                                                                                                          'Safe
                                                                                                                          JobLog))
                                                                                                                 :<|> Handler
                                                                                                                        (JobOutput
                                                                                                                           JobLog)))))
                                                                                           :<|> ((HyperdataGraphAPI
                                                                                                  -> Handler
                                                                                                       NodeId)
                                                                                                 :<|> (Handler
                                                                                                         (Headers
                                                                                                            '[Header
                                                                                                                "Content-Disposition"
                                                                                                                Text]
                                                                                                            Graph)
                                                                                                       :<|> (Handler
                                                                                                               GraphVersions
                                                                                                             :<|> Handler
                                                                                                                    Graph)))))
                                                                                 :<|> ((NodeId
                                                                                        -> ([NodeType]
                                                                                            -> Handler
                                                                                                 (Tree
                                                                                                    NodeTree))
                                                                                           :<|> ([NodeType]
                                                                                                 -> Handler
                                                                                                      (Tree
                                                                                                         NodeTree)))
                                                                                       :<|> ((NodeId
                                                                                              -> Handler
                                                                                                   (JobStatus
                                                                                                      'Safe
                                                                                                      JobLog)
                                                                                                 :<|> ((JobInput
                                                                                                          Maybe
                                                                                                          NewWithForm
                                                                                                        -> Handler
                                                                                                             (JobStatus
                                                                                                                'Safe
                                                                                                                JobLog))
                                                                                                       :<|> (ID
                                                                                                               'Unsafe
                                                                                                               "job"
                                                                                                             -> (Maybe
                                                                                                                   Limit
                                                                                                                 -> Maybe
                                                                                                                      Offset
                                                                                                                 -> Handler
                                                                                                                      (JobStatus
                                                                                                                         'Safe
                                                                                                                         JobLog))
                                                                                                                :<|> ((Maybe
                                                                                                                         Limit
                                                                                                                       -> Maybe
                                                                                                                            Offset
                                                                                                                       -> Handler
                                                                                                                            (JobStatus
                                                                                                                               'Safe
                                                                                                                               JobLog))
                                                                                                                      :<|> Handler
                                                                                                                             (JobOutput
                                                                                                                                JobLog)))))
                                                                                             :<|> ((NodeId
                                                                                                    -> Handler
                                                                                                         (JobStatus
                                                                                                            'Safe
                                                                                                            JobLog)
                                                                                                       :<|> ((JobInput
                                                                                                                Maybe
                                                                                                                WithQuery
                                                                                                              -> Handler
                                                                                                                   (JobStatus
                                                                                                                      'Safe
                                                                                                                      JobLog))
                                                                                                             :<|> (ID
                                                                                                                     'Unsafe
                                                                                                                     "job"
                                                                                                                   -> (Maybe
                                                                                                                         Limit
                                                                                                                       -> Maybe
                                                                                                                            Offset
                                                                                                                       -> Handler
                                                                                                                            (JobStatus
                                                                                                                               'Safe
                                                                                                                               JobLog))
                                                                                                                      :<|> ((Maybe
                                                                                                                               Limit
                                                                                                                             -> Maybe
                                                                                                                                  Offset
                                                                                                                             -> Handler
                                                                                                                                  (JobStatus
                                                                                                                                     'Safe
                                                                                                                                     JobLog))
                                                                                                                            :<|> Handler
                                                                                                                                   (JobOutput
                                                                                                                                      JobLog)))))
                                                                                                   :<|> ((NodeId
                                                                                                          -> Handler
                                                                                                               (Headers
                                                                                                                  '[Header
                                                                                                                      "Content-Disposition"
                                                                                                                      Text]
                                                                                                                  (Map
                                                                                                                     NgramsType
                                                                                                                     (Versioned
                                                                                                                        NgramsTableMap))))
                                                                                                         :<|> ((NodeId
                                                                                                                -> Handler
                                                                                                                     (JobStatus
                                                                                                                        'Safe
                                                                                                                        JobLog)
                                                                                                                   :<|> ((JobInput
                                                                                                                            Maybe
                                                                                                                            WithFile
                                                                                                                          -> Handler
                                                                                                                               (JobStatus
                                                                                                                                  'Safe
                                                                                                                                  JobLog))
                                                                                                                         :<|> (ID
                                                                                                                                 'Unsafe
                                                                                                                                 "job"
                                                                                                                               -> (Maybe
                                                                                                                                     Limit
                                                                                                                                   -> Maybe
                                                                                                                                        Offset
                                                                                                                                   -> Handler
                                                                                                                                        (JobStatus
                                                                                                                                           'Safe
                                                                                                                                           JobLog))
                                                                                                                                  :<|> ((Maybe
                                                                                                                                           Limit
                                                                                                                                         -> Maybe
                                                                                                                                              Offset
                                                                                                                                         -> Handler
                                                                                                                                              (JobStatus
                                                                                                                                                 'Safe
                                                                                                                                                 JobLog))
                                                                                                                                        :<|> Handler
                                                                                                                                               (JobOutput
                                                                                                                                                  JobLog)))))
                                                                                                               :<|> (NodeId
                                                                                                                     -> Handler
                                                                                                                          (JobStatus
                                                                                                                             'Safe
                                                                                                                             JobLog)
                                                                                                                        :<|> ((JobInput
                                                                                                                                 Maybe
                                                                                                                                 WithTextFile
                                                                                                                               -> Handler
                                                                                                                                    (JobStatus
                                                                                                                                       'Safe
                                                                                                                                       JobLog))
                                                                                                                              :<|> (ID
                                                                                                                                      'Unsafe
                                                                                                                                      "job"
                                                                                                                                    -> (Maybe
                                                                                                                                          Limit
                                                                                                                                        -> Maybe
                                                                                                                                             Offset
                                                                                                                                        -> Handler
                                                                                                                                             (JobStatus
                                                                                                                                                'Safe
                                                                                                                                                JobLog))
                                                                                                                                       :<|> ((Maybe
                                                                                                                                                Limit
                                                                                                                                              -> Maybe
                                                                                                                                                   Offset
                                                                                                                                              -> Handler
                                                                                                                                                   (JobStatus
                                                                                                                                                      'Safe
                                                                                                                                                      JobLog))
                                                                                                                                             :<|> Handler
                                                                                                                                                    (JobOutput
                                                                                                                                                       JobLog))))))))))))))))))))
                       :<|> (Handler [PublicData]
                             :<|> (NodeId
                                   -> Handler
                                        (Headers '[Header "Content-Type" Text] BSResponse))))))
          :<|> ((AuthResult AuthenticatedUser
                 -> (GQLRequest -> Handler GQLResponse) :<|> Handler ByteString)
                :<|> Tagged Handler Application)))
-> ((Handler Sample :<|> ([Text] -> Handler Value))
    :<|> Tagged Handler Application)
   :<|> ((Handler Value
          :<|> (Handler
                  (SwaggerUiHtml "swagger-ui" ("swagger.json" :> Get '[JSON] Value))
                :<|> (Handler
                        (SwaggerUiHtml "swagger-ui" ("swagger.json" :> Get '[JSON] Value))
                      :<|> Tagged Handler Application)))
         :<|> (((AuthRequest -> Handler AuthResponse)
                :<|> (Handler Text
                      :<|> ((AuthResult AuthenticatedUser
                             -> ((Handler [Node HyperdataUser] :<|> Handler Int)
                                 :<|> ([NodeId] -> Handler Int))
                                :<|> ((NodeId
                                       -> Handler
                                            (NodePoly
                                               NodeId
                                               (Maybe Text)
                                               Int
                                               Int
                                               (Maybe NodeId)
                                               Text
                                               UTCTime
                                               HyperdataAny)
                                          :<|> ((RenameNode -> Handler [Int])
                                                :<|> ((PostNode -> Handler [NodeId])
                                                      :<|> ((Handler (JobStatus 'Safe JobLog)
                                                             :<|> ((JobInput Maybe PostNode
                                                                    -> Handler
                                                                         (JobStatus 'Safe JobLog))
                                                                   :<|> (ID 'Unsafe "job"
                                                                         -> (Maybe Limit
                                                                             -> Maybe Offset
                                                                             -> Handler
                                                                                  (JobStatus
                                                                                     'Safe JobLog))
                                                                            :<|> ((Maybe Limit
                                                                                   -> Maybe Offset
                                                                                   -> Handler
                                                                                        (JobStatus
                                                                                           'Safe
                                                                                           JobLog))
                                                                                  :<|> Handler
                                                                                         (JobOutput
                                                                                            JobLog)))))
                                                            :<|> ((Handler (JobStatus 'Safe JobLog)
                                                                   :<|> ((JobInput
                                                                            Maybe FrameCalcUpload
                                                                          -> Handler
                                                                               (JobStatus
                                                                                  'Safe JobLog))
                                                                         :<|> (ID 'Unsafe "job"
                                                                               -> (Maybe Limit
                                                                                   -> Maybe Offset
                                                                                   -> Handler
                                                                                        (JobStatus
                                                                                           'Safe
                                                                                           JobLog))
                                                                                  :<|> ((Maybe Limit
                                                                                         -> Maybe
                                                                                              Offset
                                                                                         -> Handler
                                                                                              (JobStatus
                                                                                                 'Safe
                                                                                                 JobLog))
                                                                                        :<|> Handler
                                                                                               (JobOutput
                                                                                                  JobLog)))))
                                                                  :<|> ((HyperdataAny
                                                                         -> Handler Int)
                                                                        :<|> ((Handler
                                                                                 (JobStatus
                                                                                    'Safe JobLog)
                                                                               :<|> ((JobInput
                                                                                        Maybe
                                                                                        UpdateNodeParams
                                                                                      -> Handler
                                                                                           (JobStatus
                                                                                              'Safe
                                                                                              JobLog))
                                                                                     :<|> (ID
                                                                                             'Unsafe
                                                                                             "job"
                                                                                           -> (Maybe
                                                                                                 Limit
                                                                                               -> Maybe
                                                                                                    Offset
                                                                                               -> Handler
                                                                                                    (JobStatus
                                                                                                       'Safe
                                                                                                       JobLog))
                                                                                              :<|> ((Maybe
                                                                                                       Limit
                                                                                                     -> Maybe
                                                                                                          Offset
                                                                                                     -> Handler
                                                                                                          (JobStatus
                                                                                                             'Safe
                                                                                                             JobLog))
                                                                                                    :<|> Handler
                                                                                                           (JobOutput
                                                                                                              JobLog)))))
                                                                              :<|> (Handler Int
                                                                                    :<|> ((Maybe
                                                                                             NodeType
                                                                                           -> Maybe
                                                                                                Int
                                                                                           -> Maybe
                                                                                                Int
                                                                                           -> Handler
                                                                                                (TableResult
                                                                                                   (NodePoly
                                                                                                      NodeId
                                                                                                      (Maybe
                                                                                                         Text)
                                                                                                      Int
                                                                                                      Int
                                                                                                      (Maybe
                                                                                                         NodeId)
                                                                                                      Text
                                                                                                      UTCTime
                                                                                                      HyperdataAny)))
                                                                                          :<|> (((Maybe
                                                                                                    TabType
                                                                                                  -> Maybe
                                                                                                       NodeId
                                                                                                  -> Maybe
                                                                                                       Int
                                                                                                  -> Maybe
                                                                                                       Int
                                                                                                  -> Maybe
                                                                                                       OrderBy
                                                                                                  -> Maybe
                                                                                                       Text
                                                                                                  -> Handler
                                                                                                       (HashedResponse
                                                                                                          FacetTableResult))
                                                                                                 :<|> ((TableQuery
                                                                                                        -> Handler
                                                                                                             FacetTableResult)
                                                                                                       :<|> (Maybe
                                                                                                               TabType
                                                                                                             -> Handler
                                                                                                                  Text)))
                                                                                                :<|> (((TabType
                                                                                                        -> NodeId
                                                                                                        -> Int
                                                                                                        -> Maybe
                                                                                                             Int
                                                                                                        -> Maybe
                                                                                                             ListType
                                                                                                        -> Maybe
                                                                                                             Int
                                                                                                        -> Maybe
                                                                                                             Int
                                                                                                        -> Maybe
                                                                                                             OrderBy
                                                                                                        -> Maybe
                                                                                                             Text
                                                                                                        -> Handler
                                                                                                             (VersionedWithCount
                                                                                                                NgramsTable))
                                                                                                       :<|> ((TabType
                                                                                                              -> NodeId
                                                                                                              -> Versioned
                                                                                                                   NgramsTablePatch
                                                                                                              -> Handler
                                                                                                                   (Versioned
                                                                                                                      NgramsTablePatch))
                                                                                                             :<|> ((TabType
                                                                                                                    -> NodeId
                                                                                                                    -> Handler
                                                                                                                         Int)
                                                                                                                   :<|> ((TabType
                                                                                                                          -> NodeId
                                                                                                                          -> Handler
                                                                                                                               Int)
                                                                                                                         :<|> (Handler
                                                                                                                                 (JobStatus
                                                                                                                                    'Safe
                                                                                                                                    JobLog)
                                                                                                                               :<|> ((JobInput
                                                                                                                                        Maybe
                                                                                                                                        UpdateTableNgramsCharts
                                                                                                                                      -> Handler
                                                                                                                                           (JobStatus
                                                                                                                                              'Safe
                                                                                                                                              JobLog))
                                                                                                                                     :<|> (ID
                                                                                                                                             'Unsafe
                                                                                                                                             "job"
                                                                                                                                           -> (Maybe
                                                                                                                                                 Limit
                                                                                                                                               -> Maybe
                                                                                                                                                    Offset
                                                                                                                                               -> Handler
                                                                                                                                                    (JobStatus
                                                                                                                                                       'Safe
                                                                                                                                                       JobLog))
                                                                                                                                              :<|> ((Maybe
                                                                                                                                                       Limit
                                                                                                                                                     -> Maybe
                                                                                                                                                          Offset
                                                                                                                                                     -> Handler
                                                                                                                                                          (JobStatus
                                                                                                                                                             'Safe
                                                                                                                                                             JobLog))
                                                                                                                                                    :<|> Handler
                                                                                                                                                           (JobOutput
                                                                                                                                                              JobLog)))))))))
                                                                                                      :<|> ((NodesToCategory
                                                                                                             -> Handler
                                                                                                                  [Int])
                                                                                                            :<|> ((NodesToScore
                                                                                                                   -> Handler
                                                                                                                        [Int])
                                                                                                                  :<|> ((SearchQuery
                                                                                                                         -> Maybe
                                                                                                                              Int
                                                                                                                         -> Maybe
                                                                                                                              Int
                                                                                                                         -> Maybe
                                                                                                                              OrderBy
                                                                                                                         -> Handler
                                                                                                                              SearchResult)
                                                                                                                        :<|> ((ShareNodeParams
                                                                                                                               -> Handler
                                                                                                                                    Int)
                                                                                                                              :<|> ((NodeId
                                                                                                                                     -> Maybe
                                                                                                                                          NodeId
                                                                                                                                     -> Handler
                                                                                                                                          Int)
                                                                                                                                    :<|> (Handler
                                                                                                                                            [NodeId]
                                                                                                                                          :<|> ((Maybe
                                                                                                                                                   TabType
                                                                                                                                                 -> Maybe
                                                                                                                                                      Int
                                                                                                                                                 -> Maybe
                                                                                                                                                      Int
                                                                                                                                                 -> Maybe
                                                                                                                                                      OrderBy
                                                                                                                                                 -> Handler
                                                                                                                                                      [FacetDoc])
                                                                                                                                                :<|> (((Maybe
                                                                                                                                                          NodeId
                                                                                                                                                        -> TabType
                                                                                                                                                        -> Maybe
                                                                                                                                                             Int
                                                                                                                                                        -> Handler
                                                                                                                                                             (HashedResponse
                                                                                                                                                                Metrics))
                                                                                                                                                       :<|> ((Maybe
                                                                                                                                                                NodeId
                                                                                                                                                              -> TabType
                                                                                                                                                              -> Maybe
                                                                                                                                                                   Int
                                                                                                                                                              -> Handler
                                                                                                                                                                   ())
                                                                                                                                                             :<|> (Maybe
                                                                                                                                                                     NodeId
                                                                                                                                                                   -> TabType
                                                                                                                                                                   -> Handler
                                                                                                                                                                        Text)))
                                                                                                                                                      :<|> (((Maybe
                                                                                                                                                                UTCTime
                                                                                                                                                              -> Maybe
                                                                                                                                                                   UTCTime
                                                                                                                                                              -> Maybe
                                                                                                                                                                   NodeId
                                                                                                                                                              -> TabType
                                                                                                                                                              -> Handler
                                                                                                                                                                   (HashedResponse
                                                                                                                                                                      (ChartMetrics
                                                                                                                                                                         Histo)))
                                                                                                                                                             :<|> ((Maybe
                                                                                                                                                                      NodeId
                                                                                                                                                                    -> TabType
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         Int
                                                                                                                                                                    -> Handler
                                                                                                                                                                         ())
                                                                                                                                                                   :<|> (Maybe
                                                                                                                                                                           NodeId
                                                                                                                                                                         -> TabType
                                                                                                                                                                         -> Handler
                                                                                                                                                                              Text)))
                                                                                                                                                            :<|> (((Maybe
                                                                                                                                                                      UTCTime
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         UTCTime
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                    -> TabType
                                                                                                                                                                    -> Handler
                                                                                                                                                                         (HashedResponse
                                                                                                                                                                            (ChartMetrics
                                                                                                                                                                               Histo)))
                                                                                                                                                                   :<|> ((Maybe
                                                                                                                                                                            NodeId
                                                                                                                                                                          -> TabType
                                                                                                                                                                          -> Maybe
                                                                                                                                                                               Int
                                                                                                                                                                          -> Handler
                                                                                                                                                                               ())
                                                                                                                                                                         :<|> (Maybe
                                                                                                                                                                                 NodeId
                                                                                                                                                                               -> TabType
                                                                                                                                                                               -> Handler
                                                                                                                                                                                    Text)))
                                                                                                                                                                  :<|> (((Maybe
                                                                                                                                                                            UTCTime
                                                                                                                                                                          -> Maybe
                                                                                                                                                                               UTCTime
                                                                                                                                                                          -> Maybe
                                                                                                                                                                               NodeId
                                                                                                                                                                          -> TabType
                                                                                                                                                                          -> ListType
                                                                                                                                                                          -> Handler
                                                                                                                                                                               (HashedResponse
                                                                                                                                                                                  (ChartMetrics
                                                                                                                                                                                     (Vector
                                                                                                                                                                                        NgramsTree))))
                                                                                                                                                                         :<|> ((Maybe
                                                                                                                                                                                  NodeId
                                                                                                                                                                                -> TabType
                                                                                                                                                                                -> ListType
                                                                                                                                                                                -> Handler
                                                                                                                                                                                     ())
                                                                                                                                                                               :<|> (Maybe
                                                                                                                                                                                       NodeId
                                                                                                                                                                                     -> TabType
                                                                                                                                                                                     -> ListType
                                                                                                                                                                                     -> Handler
                                                                                                                                                                                          Text)))
                                                                                                                                                                        :<|> (((Maybe
                                                                                                                                                                                  NodeId
                                                                                                                                                                                -> Maybe
                                                                                                                                                                                     Int
                                                                                                                                                                                -> Maybe
                                                                                                                                                                                     Int
                                                                                                                                                                                -> Handler
                                                                                                                                                                                     SVG)
                                                                                                                                                                               :<|> (Maybe
                                                                                                                                                                                       NodeId
                                                                                                                                                                                     -> Handler
                                                                                                                                                                                          NodeId))
                                                                                                                                                                              :<|> ((NodeId
                                                                                                                                                                                     -> Handler
                                                                                                                                                                                          [Int])
                                                                                                                                                                                    :<|> ((NodeId
                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                Int)
                                                                                                                                                                                          :<|> (Handler
                                                                                                                                                                                                  (Headers
                                                                                                                                                                                                     '[Header
                                                                                                                                                                                                         "Content-Type"
                                                                                                                                                                                                         Text]
                                                                                                                                                                                                     BSResponse)
                                                                                                                                                                                                :<|> ((Handler
                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                            JobLog)
                                                                                                                                                                                                       :<|> ((JobInput
                                                                                                                                                                                                                Maybe
                                                                                                                                                                                                                NewWithFile
                                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                                   (JobStatus
                                                                                                                                                                                                                      'Safe
                                                                                                                                                                                                                      JobLog))
                                                                                                                                                                                                             :<|> (ID
                                                                                                                                                                                                                     'Unsafe
                                                                                                                                                                                                                     "job"
                                                                                                                                                                                                                   -> (Maybe
                                                                                                                                                                                                                         Limit
                                                                                                                                                                                                                       -> Maybe
                                                                                                                                                                                                                            Offset
                                                                                                                                                                                                                       -> Handler
                                                                                                                                                                                                                            (JobStatus
                                                                                                                                                                                                                               'Safe
                                                                                                                                                                                                                               JobLog))
                                                                                                                                                                                                                      :<|> ((Maybe
                                                                                                                                                                                                                               Limit
                                                                                                                                                                                                                             -> Maybe
                                                                                                                                                                                                                                  Offset
                                                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                                                  (JobStatus
                                                                                                                                                                                                                                     'Safe
                                                                                                                                                                                                                                     JobLog))
                                                                                                                                                                                                                            :<|> Handler
                                                                                                                                                                                                                                   (JobOutput
                                                                                                                                                                                                                                      JobLog)))))
                                                                                                                                                                                                      :<|> ((Handler
                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                  JobLog)
                                                                                                                                                                                                             :<|> ((JobInput
                                                                                                                                                                                                                      Maybe
                                                                                                                                                                                                                      Params
                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                   :<|> (ID
                                                                                                                                                                                                                           'Unsafe
                                                                                                                                                                                                                           "job"
                                                                                                                                                                                                                         -> (Maybe
                                                                                                                                                                                                                               Limit
                                                                                                                                                                                                                             -> Maybe
                                                                                                                                                                                                                                  Offset
                                                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                                                  (JobStatus
                                                                                                                                                                                                                                     'Safe
                                                                                                                                                                                                                                     JobLog))
                                                                                                                                                                                                                            :<|> ((Maybe
                                                                                                                                                                                                                                     Limit
                                                                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                                                                        Offset
                                                                                                                                                                                                                                   -> Handler
                                                                                                                                                                                                                                        (JobStatus
                                                                                                                                                                                                                                           'Safe
                                                                                                                                                                                                                                           JobLog))
                                                                                                                                                                                                                                  :<|> Handler
                                                                                                                                                                                                                                         (JobOutput
                                                                                                                                                                                                                                            JobLog)))))
                                                                                                                                                                                                            :<|> (Handler
                                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                                       JobLog)
                                                                                                                                                                                                                  :<|> ((JobInput
                                                                                                                                                                                                                           Maybe
                                                                                                                                                                                                                           DocumentUpload
                                                                                                                                                                                                                         -> Handler
                                                                                                                                                                                                                              (JobStatus
                                                                                                                                                                                                                                 'Safe
                                                                                                                                                                                                                                 JobLog))
                                                                                                                                                                                                                        :<|> (ID
                                                                                                                                                                                                                                'Unsafe
                                                                                                                                                                                                                                "job"
                                                                                                                                                                                                                              -> (Maybe
                                                                                                                                                                                                                                    Limit
                                                                                                                                                                                                                                  -> Maybe
                                                                                                                                                                                                                                       Offset
                                                                                                                                                                                                                                  -> Handler
                                                                                                                                                                                                                                       (JobStatus
                                                                                                                                                                                                                                          'Safe
                                                                                                                                                                                                                                          JobLog))
                                                                                                                                                                                                                                 :<|> ((Maybe
                                                                                                                                                                                                                                          Limit
                                                                                                                                                                                                                                        -> Maybe
                                                                                                                                                                                                                                             Offset
                                                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                                                             (JobStatus
                                                                                                                                                                                                                                                'Safe
                                                                                                                                                                                                                                                JobLog))
                                                                                                                                                                                                                                       :<|> Handler
                                                                                                                                                                                                                                              (JobOutput
                                                                                                                                                                                                                                                 JobLog)))))))))))))))))))))))))))))))))
                                      :<|> ((NodeId
                                             -> Handler
                                                  (NodePoly
                                                     NodeId
                                                     (Maybe Text)
                                                     Int
                                                     Int
                                                     (Maybe NodeId)
                                                     Text
                                                     UTCTime
                                                     HyperdataCorpus)
                                                :<|> ((RenameNode -> Handler [Int])
                                                      :<|> ((PostNode -> Handler [NodeId])
                                                            :<|> ((Handler (JobStatus 'Safe JobLog)
                                                                   :<|> ((JobInput Maybe PostNode
                                                                          -> Handler
                                                                               (JobStatus
                                                                                  'Safe JobLog))
                                                                         :<|> (ID 'Unsafe "job"
                                                                               -> (Maybe Limit
                                                                                   -> Maybe Offset
                                                                                   -> Handler
                                                                                        (JobStatus
                                                                                           'Safe
                                                                                           JobLog))
                                                                                  :<|> ((Maybe Limit
                                                                                         -> Maybe
                                                                                              Offset
                                                                                         -> Handler
                                                                                              (JobStatus
                                                                                                 'Safe
                                                                                                 JobLog))
                                                                                        :<|> Handler
                                                                                               (JobOutput
                                                                                                  JobLog)))))
                                                                  :<|> ((Handler
                                                                           (JobStatus 'Safe JobLog)
                                                                         :<|> ((JobInput
                                                                                  Maybe
                                                                                  FrameCalcUpload
                                                                                -> Handler
                                                                                     (JobStatus
                                                                                        'Safe
                                                                                        JobLog))
                                                                               :<|> (ID
                                                                                       'Unsafe "job"
                                                                                     -> (Maybe Limit
                                                                                         -> Maybe
                                                                                              Offset
                                                                                         -> Handler
                                                                                              (JobStatus
                                                                                                 'Safe
                                                                                                 JobLog))
                                                                                        :<|> ((Maybe
                                                                                                 Limit
                                                                                               -> Maybe
                                                                                                    Offset
                                                                                               -> Handler
                                                                                                    (JobStatus
                                                                                                       'Safe
                                                                                                       JobLog))
                                                                                              :<|> Handler
                                                                                                     (JobOutput
                                                                                                        JobLog)))))
                                                                        :<|> ((HyperdataCorpus
                                                                               -> Handler Int)
                                                                              :<|> ((Handler
                                                                                       (JobStatus
                                                                                          'Safe
                                                                                          JobLog)
                                                                                     :<|> ((JobInput
                                                                                              Maybe
                                                                                              UpdateNodeParams
                                                                                            -> Handler
                                                                                                 (JobStatus
                                                                                                    'Safe
                                                                                                    JobLog))
                                                                                           :<|> (ID
                                                                                                   'Unsafe
                                                                                                   "job"
                                                                                                 -> (Maybe
                                                                                                       Limit
                                                                                                     -> Maybe
                                                                                                          Offset
                                                                                                     -> Handler
                                                                                                          (JobStatus
                                                                                                             'Safe
                                                                                                             JobLog))
                                                                                                    :<|> ((Maybe
                                                                                                             Limit
                                                                                                           -> Maybe
                                                                                                                Offset
                                                                                                           -> Handler
                                                                                                                (JobStatus
                                                                                                                   'Safe
                                                                                                                   JobLog))
                                                                                                          :<|> Handler
                                                                                                                 (JobOutput
                                                                                                                    JobLog)))))
                                                                                    :<|> (Handler
                                                                                            Int
                                                                                          :<|> ((Maybe
                                                                                                   NodeType
                                                                                                 -> Maybe
                                                                                                      Int
                                                                                                 -> Maybe
                                                                                                      Int
                                                                                                 -> Handler
                                                                                                      (TableResult
                                                                                                         (NodePoly
                                                                                                            NodeId
                                                                                                            (Maybe
                                                                                                               Text)
                                                                                                            Int
                                                                                                            Int
                                                                                                            (Maybe
                                                                                                               NodeId)
                                                                                                            Text
                                                                                                            UTCTime
                                                                                                            HyperdataCorpus)))
                                                                                                :<|> (((Maybe
                                                                                                          TabType
                                                                                                        -> Maybe
                                                                                                             NodeId
                                                                                                        -> Maybe
                                                                                                             Int
                                                                                                        -> Maybe
                                                                                                             Int
                                                                                                        -> Maybe
                                                                                                             OrderBy
                                                                                                        -> Maybe
                                                                                                             Text
                                                                                                        -> Handler
                                                                                                             (HashedResponse
                                                                                                                FacetTableResult))
                                                                                                       :<|> ((TableQuery
                                                                                                              -> Handler
                                                                                                                   FacetTableResult)
                                                                                                             :<|> (Maybe
                                                                                                                     TabType
                                                                                                                   -> Handler
                                                                                                                        Text)))
                                                                                                      :<|> (((TabType
                                                                                                              -> NodeId
                                                                                                              -> Int
                                                                                                              -> Maybe
                                                                                                                   Int
                                                                                                              -> Maybe
                                                                                                                   ListType
                                                                                                              -> Maybe
                                                                                                                   Int
                                                                                                              -> Maybe
                                                                                                                   Int
                                                                                                              -> Maybe
                                                                                                                   OrderBy
                                                                                                              -> Maybe
                                                                                                                   Text
                                                                                                              -> Handler
                                                                                                                   (VersionedWithCount
                                                                                                                      NgramsTable))
                                                                                                             :<|> ((TabType
                                                                                                                    -> NodeId
                                                                                                                    -> Versioned
                                                                                                                         NgramsTablePatch
                                                                                                                    -> Handler
                                                                                                                         (Versioned
                                                                                                                            NgramsTablePatch))
                                                                                                                   :<|> ((TabType
                                                                                                                          -> NodeId
                                                                                                                          -> Handler
                                                                                                                               Int)
                                                                                                                         :<|> ((TabType
                                                                                                                                -> NodeId
                                                                                                                                -> Handler
                                                                                                                                     Int)
                                                                                                                               :<|> (Handler
                                                                                                                                       (JobStatus
                                                                                                                                          'Safe
                                                                                                                                          JobLog)
                                                                                                                                     :<|> ((JobInput
                                                                                                                                              Maybe
                                                                                                                                              UpdateTableNgramsCharts
                                                                                                                                            -> Handler
                                                                                                                                                 (JobStatus
                                                                                                                                                    'Safe
                                                                                                                                                    JobLog))
                                                                                                                                           :<|> (ID
                                                                                                                                                   'Unsafe
                                                                                                                                                   "job"
                                                                                                                                                 -> (Maybe
                                                                                                                                                       Limit
                                                                                                                                                     -> Maybe
                                                                                                                                                          Offset
                                                                                                                                                     -> Handler
                                                                                                                                                          (JobStatus
                                                                                                                                                             'Safe
                                                                                                                                                             JobLog))
                                                                                                                                                    :<|> ((Maybe
                                                                                                                                                             Limit
                                                                                                                                                           -> Maybe
                                                                                                                                                                Offset
                                                                                                                                                           -> Handler
                                                                                                                                                                (JobStatus
                                                                                                                                                                   'Safe
                                                                                                                                                                   JobLog))
                                                                                                                                                          :<|> Handler
                                                                                                                                                                 (JobOutput
                                                                                                                                                                    JobLog)))))))))
                                                                                                            :<|> ((NodesToCategory
                                                                                                                   -> Handler
                                                                                                                        [Int])
                                                                                                                  :<|> ((NodesToScore
                                                                                                                         -> Handler
                                                                                                                              [Int])
                                                                                                                        :<|> ((SearchQuery
                                                                                                                               -> Maybe
                                                                                                                                    Int
                                                                                                                               -> Maybe
                                                                                                                                    Int
                                                                                                                               -> Maybe
                                                                                                                                    OrderBy
                                                                                                                               -> Handler
                                                                                                                                    SearchResult)
                                                                                                                              :<|> ((ShareNodeParams
                                                                                                                                     -> Handler
                                                                                                                                          Int)
                                                                                                                                    :<|> ((NodeId
                                                                                                                                           -> Maybe
                                                                                                                                                NodeId
                                                                                                                                           -> Handler
                                                                                                                                                Int)
                                                                                                                                          :<|> (Handler
                                                                                                                                                  [NodeId]
                                                                                                                                                :<|> ((Maybe
                                                                                                                                                         TabType
                                                                                                                                                       -> Maybe
                                                                                                                                                            Int
                                                                                                                                                       -> Maybe
                                                                                                                                                            Int
                                                                                                                                                       -> Maybe
                                                                                                                                                            OrderBy
                                                                                                                                                       -> Handler
                                                                                                                                                            [FacetDoc])
                                                                                                                                                      :<|> (((Maybe
                                                                                                                                                                NodeId
                                                                                                                                                              -> TabType
                                                                                                                                                              -> Maybe
                                                                                                                                                                   Int
                                                                                                                                                              -> Handler
                                                                                                                                                                   (HashedResponse
                                                                                                                                                                      Metrics))
                                                                                                                                                             :<|> ((Maybe
                                                                                                                                                                      NodeId
                                                                                                                                                                    -> TabType
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         Int
                                                                                                                                                                    -> Handler
                                                                                                                                                                         ())
                                                                                                                                                                   :<|> (Maybe
                                                                                                                                                                           NodeId
                                                                                                                                                                         -> TabType
                                                                                                                                                                         -> Handler
                                                                                                                                                                              Text)))
                                                                                                                                                            :<|> (((Maybe
                                                                                                                                                                      UTCTime
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         UTCTime
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                    -> TabType
                                                                                                                                                                    -> Handler
                                                                                                                                                                         (HashedResponse
                                                                                                                                                                            (ChartMetrics
                                                                                                                                                                               Histo)))
                                                                                                                                                                   :<|> ((Maybe
                                                                                                                                                                            NodeId
                                                                                                                                                                          -> TabType
                                                                                                                                                                          -> Maybe
                                                                                                                                                                               Int
                                                                                                                                                                          -> Handler
                                                                                                                                                                               ())
                                                                                                                                                                         :<|> (Maybe
                                                                                                                                                                                 NodeId
                                                                                                                                                                               -> TabType
                                                                                                                                                                               -> Handler
                                                                                                                                                                                    Text)))
                                                                                                                                                                  :<|> (((Maybe
                                                                                                                                                                            UTCTime
                                                                                                                                                                          -> Maybe
                                                                                                                                                                               UTCTime
                                                                                                                                                                          -> Maybe
                                                                                                                                                                               NodeId
                                                                                                                                                                          -> TabType
                                                                                                                                                                          -> Handler
                                                                                                                                                                               (HashedResponse
                                                                                                                                                                                  (ChartMetrics
                                                                                                                                                                                     Histo)))
                                                                                                                                                                         :<|> ((Maybe
                                                                                                                                                                                  NodeId
                                                                                                                                                                                -> TabType
                                                                                                                                                                                -> Maybe
                                                                                                                                                                                     Int
                                                                                                                                                                                -> Handler
                                                                                                                                                                                     ())
                                                                                                                                                                               :<|> (Maybe
                                                                                                                                                                                       NodeId
                                                                                                                                                                                     -> TabType
                                                                                                                                                                                     -> Handler
                                                                                                                                                                                          Text)))
                                                                                                                                                                        :<|> (((Maybe
                                                                                                                                                                                  UTCTime
                                                                                                                                                                                -> Maybe
                                                                                                                                                                                     UTCTime
                                                                                                                                                                                -> Maybe
                                                                                                                                                                                     NodeId
                                                                                                                                                                                -> TabType
                                                                                                                                                                                -> ListType
                                                                                                                                                                                -> Handler
                                                                                                                                                                                     (HashedResponse
                                                                                                                                                                                        (ChartMetrics
                                                                                                                                                                                           (Vector
                                                                                                                                                                                              NgramsTree))))
                                                                                                                                                                               :<|> ((Maybe
                                                                                                                                                                                        NodeId
                                                                                                                                                                                      -> TabType
                                                                                                                                                                                      -> ListType
                                                                                                                                                                                      -> Handler
                                                                                                                                                                                           ())
                                                                                                                                                                                     :<|> (Maybe
                                                                                                                                                                                             NodeId
                                                                                                                                                                                           -> TabType
                                                                                                                                                                                           -> ListType
                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                Text)))
                                                                                                                                                                              :<|> (((Maybe
                                                                                                                                                                                        NodeId
                                                                                                                                                                                      -> Maybe
                                                                                                                                                                                           Int
                                                                                                                                                                                      -> Maybe
                                                                                                                                                                                           Int
                                                                                                                                                                                      -> Handler
                                                                                                                                                                                           SVG)
                                                                                                                                                                                     :<|> (Maybe
                                                                                                                                                                                             NodeId
                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                NodeId))
                                                                                                                                                                                    :<|> ((NodeId
                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                [Int])
                                                                                                                                                                                          :<|> ((NodeId
                                                                                                                                                                                                 -> Handler
                                                                                                                                                                                                      Int)
                                                                                                                                                                                                :<|> (Handler
                                                                                                                                                                                                        (Headers
                                                                                                                                                                                                           '[Header
                                                                                                                                                                                                               "Content-Type"
                                                                                                                                                                                                               Text]
                                                                                                                                                                                                           BSResponse)
                                                                                                                                                                                                      :<|> ((Handler
                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                  JobLog)
                                                                                                                                                                                                             :<|> ((JobInput
                                                                                                                                                                                                                      Maybe
                                                                                                                                                                                                                      NewWithFile
                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                   :<|> (ID
                                                                                                                                                                                                                           'Unsafe
                                                                                                                                                                                                                           "job"
                                                                                                                                                                                                                         -> (Maybe
                                                                                                                                                                                                                               Limit
                                                                                                                                                                                                                             -> Maybe
                                                                                                                                                                                                                                  Offset
                                                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                                                  (JobStatus
                                                                                                                                                                                                                                     'Safe
                                                                                                                                                                                                                                     JobLog))
                                                                                                                                                                                                                            :<|> ((Maybe
                                                                                                                                                                                                                                     Limit
                                                                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                                                                        Offset
                                                                                                                                                                                                                                   -> Handler
                                                                                                                                                                                                                                        (JobStatus
                                                                                                                                                                                                                                           'Safe
                                                                                                                                                                                                                                           JobLog))
                                                                                                                                                                                                                                  :<|> Handler
                                                                                                                                                                                                                                         (JobOutput
                                                                                                                                                                                                                                            JobLog)))))
                                                                                                                                                                                                            :<|> ((Handler
                                                                                                                                                                                                                     (JobStatus
                                                                                                                                                                                                                        'Safe
                                                                                                                                                                                                                        JobLog)
                                                                                                                                                                                                                   :<|> ((JobInput
                                                                                                                                                                                                                            Maybe
                                                                                                                                                                                                                            Params
                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                         :<|> (ID
                                                                                                                                                                                                                                 'Unsafe
                                                                                                                                                                                                                                 "job"
                                                                                                                                                                                                                               -> (Maybe
                                                                                                                                                                                                                                     Limit
                                                                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                                                                        Offset
                                                                                                                                                                                                                                   -> Handler
                                                                                                                                                                                                                                        (JobStatus
                                                                                                                                                                                                                                           'Safe
                                                                                                                                                                                                                                           JobLog))
                                                                                                                                                                                                                                  :<|> ((Maybe
                                                                                                                                                                                                                                           Limit
                                                                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                                                                              Offset
                                                                                                                                                                                                                                         -> Handler
                                                                                                                                                                                                                                              (JobStatus
                                                                                                                                                                                                                                                 'Safe
                                                                                                                                                                                                                                                 JobLog))
                                                                                                                                                                                                                                        :<|> Handler
                                                                                                                                                                                                                                               (JobOutput
                                                                                                                                                                                                                                                  JobLog)))))
                                                                                                                                                                                                                  :<|> (Handler
                                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                                             JobLog)
                                                                                                                                                                                                                        :<|> ((JobInput
                                                                                                                                                                                                                                 Maybe
                                                                                                                                                                                                                                 DocumentUpload
                                                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                                                       JobLog))
                                                                                                                                                                                                                              :<|> (ID
                                                                                                                                                                                                                                      'Unsafe
                                                                                                                                                                                                                                      "job"
                                                                                                                                                                                                                                    -> (Maybe
                                                                                                                                                                                                                                          Limit
                                                                                                                                                                                                                                        -> Maybe
                                                                                                                                                                                                                                             Offset
                                                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                                                             (JobStatus
                                                                                                                                                                                                                                                'Safe
                                                                                                                                                                                                                                                JobLog))
                                                                                                                                                                                                                                       :<|> ((Maybe
                                                                                                                                                                                                                                                Limit
                                                                                                                                                                                                                                              -> Maybe
                                                                                                                                                                                                                                                   Offset
                                                                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                                                                   (JobStatus
                                                                                                                                                                                                                                                      'Safe
                                                                                                                                                                                                                                                      JobLog))
                                                                                                                                                                                                                                             :<|> Handler
                                                                                                                                                                                                                                                    (JobOutput
                                                                                                                                                                                                                                                       JobLog)))))))))))))))))))))))))))))))))
                                            :<|> ((NodeId
                                                   -> NodeId
                                                   -> Handler
                                                        (NodePoly
                                                           NodeId
                                                           (Maybe Text)
                                                           Int
                                                           Int
                                                           (Maybe NodeId)
                                                           Text
                                                           UTCTime
                                                           HyperdataAny))
                                                  :<|> ((NodeId
                                                         -> Maybe NodeId
                                                         -> Maybe NgramsType
                                                         -> Handler Corpus)
                                                        :<|> ((NodeId
                                                               -> Handler
                                                                    (NodePoly
                                                                       NodeId
                                                                       (Maybe Text)
                                                                       Int
                                                                       Int
                                                                       (Maybe NodeId)
                                                                       Text
                                                                       UTCTime
                                                                       HyperdataAnnuaire)
                                                                  :<|> ((RenameNode
                                                                         -> Handler [Int])
                                                                        :<|> ((PostNode
                                                                               -> Handler [NodeId])
                                                                              :<|> ((Handler
                                                                                       (JobStatus
                                                                                          'Safe
                                                                                          JobLog)
                                                                                     :<|> ((JobInput
                                                                                              Maybe
                                                                                              PostNode
                                                                                            -> Handler
                                                                                                 (JobStatus
                                                                                                    'Safe
                                                                                                    JobLog))
                                                                                           :<|> (ID
                                                                                                   'Unsafe
                                                                                                   "job"
                                                                                                 -> (Maybe
                                                                                                       Limit
                                                                                                     -> Maybe
                                                                                                          Offset
                                                                                                     -> Handler
                                                                                                          (JobStatus
                                                                                                             'Safe
                                                                                                             JobLog))
                                                                                                    :<|> ((Maybe
                                                                                                             Limit
                                                                                                           -> Maybe
                                                                                                                Offset
                                                                                                           -> Handler
                                                                                                                (JobStatus
                                                                                                                   'Safe
                                                                                                                   JobLog))
                                                                                                          :<|> Handler
                                                                                                                 (JobOutput
                                                                                                                    JobLog)))))
                                                                                    :<|> ((Handler
                                                                                             (JobStatus
                                                                                                'Safe
                                                                                                JobLog)
                                                                                           :<|> ((JobInput
                                                                                                    Maybe
                                                                                                    FrameCalcUpload
                                                                                                  -> Handler
                                                                                                       (JobStatus
                                                                                                          'Safe
                                                                                                          JobLog))
                                                                                                 :<|> (ID
                                                                                                         'Unsafe
                                                                                                         "job"
                                                                                                       -> (Maybe
                                                                                                             Limit
                                                                                                           -> Maybe
                                                                                                                Offset
                                                                                                           -> Handler
                                                                                                                (JobStatus
                                                                                                                   'Safe
                                                                                                                   JobLog))
                                                                                                          :<|> ((Maybe
                                                                                                                   Limit
                                                                                                                 -> Maybe
                                                                                                                      Offset
                                                                                                                 -> Handler
                                                                                                                      (JobStatus
                                                                                                                         'Safe
                                                                                                                         JobLog))
                                                                                                                :<|> Handler
                                                                                                                       (JobOutput
                                                                                                                          JobLog)))))
                                                                                          :<|> ((HyperdataAnnuaire
                                                                                                 -> Handler
                                                                                                      Int)
                                                                                                :<|> ((Handler
                                                                                                         (JobStatus
                                                                                                            'Safe
                                                                                                            JobLog)
                                                                                                       :<|> ((JobInput
                                                                                                                Maybe
                                                                                                                UpdateNodeParams
                                                                                                              -> Handler
                                                                                                                   (JobStatus
                                                                                                                      'Safe
                                                                                                                      JobLog))
                                                                                                             :<|> (ID
                                                                                                                     'Unsafe
                                                                                                                     "job"
                                                                                                                   -> (Maybe
                                                                                                                         Limit
                                                                                                                       -> Maybe
                                                                                                                            Offset
                                                                                                                       -> Handler
                                                                                                                            (JobStatus
                                                                                                                               'Safe
                                                                                                                               JobLog))
                                                                                                                      :<|> ((Maybe
                                                                                                                               Limit
                                                                                                                             -> Maybe
                                                                                                                                  Offset
                                                                                                                             -> Handler
                                                                                                                                  (JobStatus
                                                                                                                                     'Safe
                                                                                                                                     JobLog))
                                                                                                                            :<|> Handler
                                                                                                                                   (JobOutput
                                                                                                                                      JobLog)))))
                                                                                                      :<|> (Handler
                                                                                                              Int
                                                                                                            :<|> ((Maybe
                                                                                                                     NodeType
                                                                                                                   -> Maybe
                                                                                                                        Int
                                                                                                                   -> Maybe
                                                                                                                        Int
                                                                                                                   -> Handler
                                                                                                                        (TableResult
                                                                                                                           (NodePoly
                                                                                                                              NodeId
                                                                                                                              (Maybe
                                                                                                                                 Text)
                                                                                                                              Int
                                                                                                                              Int
                                                                                                                              (Maybe
                                                                                                                                 NodeId)
                                                                                                                              Text
                                                                                                                              UTCTime
                                                                                                                              HyperdataAnnuaire)))
                                                                                                                  :<|> (((Maybe
                                                                                                                            TabType
                                                                                                                          -> Maybe
                                                                                                                               NodeId
                                                                                                                          -> Maybe
                                                                                                                               Int
                                                                                                                          -> Maybe
                                                                                                                               Int
                                                                                                                          -> Maybe
                                                                                                                               OrderBy
                                                                                                                          -> Maybe
                                                                                                                               Text
                                                                                                                          -> Handler
                                                                                                                               (HashedResponse
                                                                                                                                  FacetTableResult))
                                                                                                                         :<|> ((TableQuery
                                                                                                                                -> Handler
                                                                                                                                     FacetTableResult)
                                                                                                                               :<|> (Maybe
                                                                                                                                       TabType
                                                                                                                                     -> Handler
                                                                                                                                          Text)))
                                                                                                                        :<|> (((TabType
                                                                                                                                -> NodeId
                                                                                                                                -> Int
                                                                                                                                -> Maybe
                                                                                                                                     Int
                                                                                                                                -> Maybe
                                                                                                                                     ListType
                                                                                                                                -> Maybe
                                                                                                                                     Int
                                                                                                                                -> Maybe
                                                                                                                                     Int
                                                                                                                                -> Maybe
                                                                                                                                     OrderBy
                                                                                                                                -> Maybe
                                                                                                                                     Text
                                                                                                                                -> Handler
                                                                                                                                     (VersionedWithCount
                                                                                                                                        NgramsTable))
                                                                                                                               :<|> ((TabType
                                                                                                                                      -> NodeId
                                                                                                                                      -> Versioned
                                                                                                                                           NgramsTablePatch
                                                                                                                                      -> Handler
                                                                                                                                           (Versioned
                                                                                                                                              NgramsTablePatch))
                                                                                                                                     :<|> ((TabType
                                                                                                                                            -> NodeId
                                                                                                                                            -> Handler
                                                                                                                                                 Int)
                                                                                                                                           :<|> ((TabType
                                                                                                                                                  -> NodeId
                                                                                                                                                  -> Handler
                                                                                                                                                       Int)
                                                                                                                                                 :<|> (Handler
                                                                                                                                                         (JobStatus
                                                                                                                                                            'Safe
                                                                                                                                                            JobLog)
                                                                                                                                                       :<|> ((JobInput
                                                                                                                                                                Maybe
                                                                                                                                                                UpdateTableNgramsCharts
                                                                                                                                                              -> Handler
                                                                                                                                                                   (JobStatus
                                                                                                                                                                      'Safe
                                                                                                                                                                      JobLog))
                                                                                                                                                             :<|> (ID
                                                                                                                                                                     'Unsafe
                                                                                                                                                                     "job"
                                                                                                                                                                   -> (Maybe
                                                                                                                                                                         Limit
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            Offset
                                                                                                                                                                       -> Handler
                                                                                                                                                                            (JobStatus
                                                                                                                                                                               'Safe
                                                                                                                                                                               JobLog))
                                                                                                                                                                      :<|> ((Maybe
                                                                                                                                                                               Limit
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  Offset
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  (JobStatus
                                                                                                                                                                                     'Safe
                                                                                                                                                                                     JobLog))
                                                                                                                                                                            :<|> Handler
                                                                                                                                                                                   (JobOutput
                                                                                                                                                                                      JobLog)))))))))
                                                                                                                              :<|> ((NodesToCategory
                                                                                                                                     -> Handler
                                                                                                                                          [Int])
                                                                                                                                    :<|> ((NodesToScore
                                                                                                                                           -> Handler
                                                                                                                                                [Int])
                                                                                                                                          :<|> ((SearchQuery
                                                                                                                                                 -> Maybe
                                                                                                                                                      Int
                                                                                                                                                 -> Maybe
                                                                                                                                                      Int
                                                                                                                                                 -> Maybe
                                                                                                                                                      OrderBy
                                                                                                                                                 -> Handler
                                                                                                                                                      SearchResult)
                                                                                                                                                :<|> ((ShareNodeParams
                                                                                                                                                       -> Handler
                                                                                                                                                            Int)
                                                                                                                                                      :<|> ((NodeId
                                                                                                                                                             -> Maybe
                                                                                                                                                                  NodeId
                                                                                                                                                             -> Handler
                                                                                                                                                                  Int)
                                                                                                                                                            :<|> (Handler
                                                                                                                                                                    [NodeId]
                                                                                                                                                                  :<|> ((Maybe
                                                                                                                                                                           TabType
                                                                                                                                                                         -> Maybe
                                                                                                                                                                              Int
                                                                                                                                                                         -> Maybe
                                                                                                                                                                              Int
                                                                                                                                                                         -> Maybe
                                                                                                                                                                              OrderBy
                                                                                                                                                                         -> Handler
                                                                                                                                                                              [FacetDoc])
                                                                                                                                                                        :<|> (((Maybe
                                                                                                                                                                                  NodeId
                                                                                                                                                                                -> TabType
                                                                                                                                                                                -> Maybe
                                                                                                                                                                                     Int
                                                                                                                                                                                -> Handler
                                                                                                                                                                                     (HashedResponse
                                                                                                                                                                                        Metrics))
                                                                                                                                                                               :<|> ((Maybe
                                                                                                                                                                                        NodeId
                                                                                                                                                                                      -> TabType
                                                                                                                                                                                      -> Maybe
                                                                                                                                                                                           Int
                                                                                                                                                                                      -> Handler
                                                                                                                                                                                           ())
                                                                                                                                                                                     :<|> (Maybe
                                                                                                                                                                                             NodeId
                                                                                                                                                                                           -> TabType
                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                Text)))
                                                                                                                                                                              :<|> (((Maybe
                                                                                                                                                                                        UTCTime
                                                                                                                                                                                      -> Maybe
                                                                                                                                                                                           UTCTime
                                                                                                                                                                                      -> Maybe
                                                                                                                                                                                           NodeId
                                                                                                                                                                                      -> TabType
                                                                                                                                                                                      -> Handler
                                                                                                                                                                                           (HashedResponse
                                                                                                                                                                                              (ChartMetrics
                                                                                                                                                                                                 Histo)))
                                                                                                                                                                                     :<|> ((Maybe
                                                                                                                                                                                              NodeId
                                                                                                                                                                                            -> TabType
                                                                                                                                                                                            -> Maybe
                                                                                                                                                                                                 Int
                                                                                                                                                                                            -> Handler
                                                                                                                                                                                                 ())
                                                                                                                                                                                           :<|> (Maybe
                                                                                                                                                                                                   NodeId
                                                                                                                                                                                                 -> TabType
                                                                                                                                                                                                 -> Handler
                                                                                                                                                                                                      Text)))
                                                                                                                                                                                    :<|> (((Maybe
                                                                                                                                                                                              UTCTime
                                                                                                                                                                                            -> Maybe
                                                                                                                                                                                                 UTCTime
                                                                                                                                                                                            -> Maybe
                                                                                                                                                                                                 NodeId
                                                                                                                                                                                            -> TabType
                                                                                                                                                                                            -> Handler
                                                                                                                                                                                                 (HashedResponse
                                                                                                                                                                                                    (ChartMetrics
                                                                                                                                                                                                       Histo)))
                                                                                                                                                                                           :<|> ((Maybe
                                                                                                                                                                                                    NodeId
                                                                                                                                                                                                  -> TabType
                                                                                                                                                                                                  -> Maybe
                                                                                                                                                                                                       Int
                                                                                                                                                                                                  -> Handler
                                                                                                                                                                                                       ())
                                                                                                                                                                                                 :<|> (Maybe
                                                                                                                                                                                                         NodeId
                                                                                                                                                                                                       -> TabType
                                                                                                                                                                                                       -> Handler
                                                                                                                                                                                                            Text)))
                                                                                                                                                                                          :<|> (((Maybe
                                                                                                                                                                                                    UTCTime
                                                                                                                                                                                                  -> Maybe
                                                                                                                                                                                                       UTCTime
                                                                                                                                                                                                  -> Maybe
                                                                                                                                                                                                       NodeId
                                                                                                                                                                                                  -> TabType
                                                                                                                                                                                                  -> ListType
                                                                                                                                                                                                  -> Handler
                                                                                                                                                                                                       (HashedResponse
                                                                                                                                                                                                          (ChartMetrics
                                                                                                                                                                                                             (Vector
                                                                                                                                                                                                                NgramsTree))))
                                                                                                                                                                                                 :<|> ((Maybe
                                                                                                                                                                                                          NodeId
                                                                                                                                                                                                        -> TabType
                                                                                                                                                                                                        -> ListType
                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                             ())
                                                                                                                                                                                                       :<|> (Maybe
                                                                                                                                                                                                               NodeId
                                                                                                                                                                                                             -> TabType
                                                                                                                                                                                                             -> ListType
                                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                                  Text)))
                                                                                                                                                                                                :<|> (((Maybe
                                                                                                                                                                                                          NodeId
                                                                                                                                                                                                        -> Maybe
                                                                                                                                                                                                             Int
                                                                                                                                                                                                        -> Maybe
                                                                                                                                                                                                             Int
                                                                                                                                                                                                        -> Handler
                                                                                                                                                                                                             SVG)
                                                                                                                                                                                                       :<|> (Maybe
                                                                                                                                                                                                               NodeId
                                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                                  NodeId))
                                                                                                                                                                                                      :<|> ((NodeId
                                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                                  [Int])
                                                                                                                                                                                                            :<|> ((NodeId
                                                                                                                                                                                                                   -> Handler
                                                                                                                                                                                                                        Int)
                                                                                                                                                                                                                  :<|> (Handler
                                                                                                                                                                                                                          (Headers
                                                                                                                                                                                                                             '[Header
                                                                                                                                                                                                                                 "Content-Type"
                                                                                                                                                                                                                                 Text]
                                                                                                                                                                                                                             BSResponse)
                                                                                                                                                                                                                        :<|> ((Handler
                                                                                                                                                                                                                                 (JobStatus
                                                                                                                                                                                                                                    'Safe
                                                                                                                                                                                                                                    JobLog)
                                                                                                                                                                                                                               :<|> ((JobInput
                                                                                                                                                                                                                                        Maybe
                                                                                                                                                                                                                                        NewWithFile
                                                                                                                                                                                                                                      -> Handler
                                                                                                                                                                                                                                           (JobStatus
                                                                                                                                                                                                                                              'Safe
                                                                                                                                                                                                                                              JobLog))
                                                                                                                                                                                                                                     :<|> (ID
                                                                                                                                                                                                                                             'Unsafe
                                                                                                                                                                                                                                             "job"
                                                                                                                                                                                                                                           -> (Maybe
                                                                                                                                                                                                                                                 Limit
                                                                                                                                                                                                                                               -> Maybe
                                                                                                                                                                                                                                                    Offset
                                                                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                                                                       JobLog))
                                                                                                                                                                                                                                              :<|> ((Maybe
                                                                                                                                                                                                                                                       Limit
                                                                                                                                                                                                                                                     -> Maybe
                                                                                                                                                                                                                                                          Offset
                                                                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                                                                             JobLog))
                                                                                                                                                                                                                                                    :<|> Handler
                                                                                                                                                                                                                                                           (JobOutput
                                                                                                                                                                                                                                                              JobLog)))))
                                                                                                                                                                                                                              :<|> ((Handler
                                                                                                                                                                                                                                       (JobStatus
                                                                                                                                                                                                                                          'Safe
                                                                                                                                                                                                                                          JobLog)
                                                                                                                                                                                                                                     :<|> ((JobInput
                                                                                                                                                                                                                                              Maybe
                                                                                                                                                                                                                                              Params
                                                                                                                                                                                                                                            -> Handler
                                                                                                                                                                                                                                                 (JobStatus
                                                                                                                                                                                                                                                    'Safe
                                                                                                                                                                                                                                                    JobLog))
                                                                                                                                                                                                                                           :<|> (ID
                                                                                                                                                                                                                                                   'Unsafe
                                                                                                                                                                                                                                                   "job"
                                                                                                                                                                                                                                                 -> (Maybe
                                                                                                                                                                                                                                                       Limit
                                                                                                                                                                                                                                                     -> Maybe
                                                                                                                                                                                                                                                          Offset
                                                                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                                                                             JobLog))
                                                                                                                                                                                                                                                    :<|> ((Maybe
                                                                                                                                                                                                                                                             Limit
                                                                                                                                                                                                                                                           -> Maybe
                                                                                                                                                                                                                                                                Offset
                                                                                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                                                                                (JobStatus
                                                                                                                                                                                                                                                                   'Safe
                                                                                                                                                                                                                                                                   JobLog))
                                                                                                                                                                                                                                                          :<|> Handler
                                                                                                                                                                                                                                                                 (JobOutput
                                                                                                                                                                                                                                                                    JobLog)))))
                                                                                                                                                                                                                                    :<|> (Handler
                                                                                                                                                                                                                                            (JobStatus
                                                                                                                                                                                                                                               'Safe
                                                                                                                                                                                                                                               JobLog)
                                                                                                                                                                                                                                          :<|> ((JobInput
                                                                                                                                                                                                                                                   Maybe
                                                                                                                                                                                                                                                   DocumentUpload
                                                                                                                                                                                                                                                 -> Handler
                                                                                                                                                                                                                                                      (JobStatus
                                                                                                                                                                                                                                                         'Safe
                                                                                                                                                                                                                                                         JobLog))
                                                                                                                                                                                                                                                :<|> (ID
                                                                                                                                                                                                                                                        'Unsafe
                                                                                                                                                                                                                                                        "job"
                                                                                                                                                                                                                                                      -> (Maybe
                                                                                                                                                                                                                                                            Limit
                                                                                                                                                                                                                                                          -> Maybe
                                                                                                                                                                                                                                                               Offset
                                                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                                                         :<|> ((Maybe
                                                                                                                                                                                                                                                                  Limit
                                                                                                                                                                                                                                                                -> Maybe
                                                                                                                                                                                                                                                                     Offset
                                                                                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                                                                                     (JobStatus
                                                                                                                                                                                                                                                                        'Safe
                                                                                                                                                                                                                                                                        JobLog))
                                                                                                                                                                                                                                                               :<|> Handler
                                                                                                                                                                                                                                                                      (JobOutput
                                                                                                                                                                                                                                                                         JobLog)))))))))))))))))))))))))))))))))
                                                              :<|> ((NodeId
                                                                     -> (Handler
                                                                           (JobStatus 'Safe JobLog)
                                                                         :<|> ((JobInput
                                                                                  Maybe
                                                                                  AddContactParams
                                                                                -> Handler
                                                                                     (JobStatus
                                                                                        'Safe
                                                                                        JobLog))
                                                                               :<|> (ID
                                                                                       'Unsafe "job"
                                                                                     -> (Maybe Limit
                                                                                         -> Maybe
                                                                                              Offset
                                                                                         -> Handler
                                                                                              (JobStatus
                                                                                                 'Safe
                                                                                                 JobLog))
                                                                                        :<|> ((Maybe
                                                                                                 Limit
                                                                                               -> Maybe
                                                                                                    Offset
                                                                                               -> Handler
                                                                                                    (JobStatus
                                                                                                       'Safe
                                                                                                       JobLog))
                                                                                              :<|> Handler
                                                                                                     (JobOutput
                                                                                                        JobLog)))))
                                                                        :<|> (NodeId
                                                                              -> Handler
                                                                                   (NodePoly
                                                                                      NodeId
                                                                                      (Maybe Text)
                                                                                      Int
                                                                                      Int
                                                                                      (Maybe NodeId)
                                                                                      Text
                                                                                      UTCTime
                                                                                      HyperdataContact)))
                                                                    :<|> ((NodeId
                                                                           -> (TabType
                                                                               -> NodeId
                                                                               -> Int
                                                                               -> Maybe Int
                                                                               -> Maybe ListType
                                                                               -> Maybe Int
                                                                               -> Maybe Int
                                                                               -> Maybe OrderBy
                                                                               -> Maybe Text
                                                                               -> Handler
                                                                                    (VersionedWithCount
                                                                                       NgramsTable))
                                                                              :<|> ((TabType
                                                                                     -> NodeId
                                                                                     -> Versioned
                                                                                          NgramsTablePatch
                                                                                     -> Handler
                                                                                          (Versioned
                                                                                             NgramsTablePatch))
                                                                                    :<|> ((TabType
                                                                                           -> NodeId
                                                                                           -> Handler
                                                                                                Int)
                                                                                          :<|> ((TabType
                                                                                                 -> NodeId
                                                                                                 -> Handler
                                                                                                      Int)
                                                                                                :<|> (Handler
                                                                                                        (JobStatus
                                                                                                           'Safe
                                                                                                           JobLog)
                                                                                                      :<|> ((JobInput
                                                                                                               Maybe
                                                                                                               UpdateTableNgramsCharts
                                                                                                             -> Handler
                                                                                                                  (JobStatus
                                                                                                                     'Safe
                                                                                                                     JobLog))
                                                                                                            :<|> (ID
                                                                                                                    'Unsafe
                                                                                                                    "job"
                                                                                                                  -> (Maybe
                                                                                                                        Limit
                                                                                                                      -> Maybe
                                                                                                                           Offset
                                                                                                                      -> Handler
                                                                                                                           (JobStatus
                                                                                                                              'Safe
                                                                                                                              JobLog))
                                                                                                                     :<|> ((Maybe
                                                                                                                              Limit
                                                                                                                            -> Maybe
                                                                                                                                 Offset
                                                                                                                            -> Handler
                                                                                                                                 (JobStatus
                                                                                                                                    'Safe
                                                                                                                                    JobLog))
                                                                                                                           :<|> Handler
                                                                                                                                  (JobOutput
                                                                                                                                     JobLog)))))))))
                                                                          :<|> ((Query
                                                                                 -> Handler Counts)
                                                                                :<|> ((NodeId
                                                                                       -> Handler
                                                                                            HyperdataGraphAPI
                                                                                          :<|> ((Handler
                                                                                                   (JobStatus
                                                                                                      'Safe
                                                                                                      JobLog)
                                                                                                 :<|> ((JobInput
                                                                                                          Maybe
                                                                                                          ()
                                                                                                        -> Handler
                                                                                                             (JobStatus
                                                                                                                'Safe
                                                                                                                JobLog))
                                                                                                       :<|> (ID
                                                                                                               'Unsafe
                                                                                                               "job"
                                                                                                             -> (Maybe
                                                                                                                   Limit
                                                                                                                 -> Maybe
                                                                                                                      Offset
                                                                                                                 -> Handler
                                                                                                                      (JobStatus
                                                                                                                         'Safe
                                                                                                                         JobLog))
                                                                                                                :<|> ((Maybe
                                                                                                                         Limit
                                                                                                                       -> Maybe
                                                                                                                            Offset
                                                                                                                       -> Handler
                                                                                                                            (JobStatus
                                                                                                                               'Safe
                                                                                                                               JobLog))
                                                                                                                      :<|> Handler
                                                                                                                             (JobOutput
                                                                                                                                JobLog)))))
                                                                                                :<|> ((HyperdataGraphAPI
                                                                                                       -> Handler
                                                                                                            NodeId)
                                                                                                      :<|> (Handler
                                                                                                              (Headers
                                                                                                                 '[Header
                                                                                                                     "Content-Disposition"
                                                                                                                     Text]
                                                                                                                 Graph)
                                                                                                            :<|> (Handler
                                                                                                                    GraphVersions
                                                                                                                  :<|> Handler
                                                                                                                         Graph)))))
                                                                                      :<|> ((NodeId
                                                                                             -> ([NodeType]
                                                                                                 -> Handler
                                                                                                      (Tree
                                                                                                         NodeTree))
                                                                                                :<|> ([NodeType]
                                                                                                      -> Handler
                                                                                                           (Tree
                                                                                                              NodeTree)))
                                                                                            :<|> ((NodeId
                                                                                                   -> Handler
                                                                                                        (JobStatus
                                                                                                           'Safe
                                                                                                           JobLog)
                                                                                                      :<|> ((JobInput
                                                                                                               Maybe
                                                                                                               NewWithForm
                                                                                                             -> Handler
                                                                                                                  (JobStatus
                                                                                                                     'Safe
                                                                                                                     JobLog))
                                                                                                            :<|> (ID
                                                                                                                    'Unsafe
                                                                                                                    "job"
                                                                                                                  -> (Maybe
                                                                                                                        Limit
                                                                                                                      -> Maybe
                                                                                                                           Offset
                                                                                                                      -> Handler
                                                                                                                           (JobStatus
                                                                                                                              'Safe
                                                                                                                              JobLog))
                                                                                                                     :<|> ((Maybe
                                                                                                                              Limit
                                                                                                                            -> Maybe
                                                                                                                                 Offset
                                                                                                                            -> Handler
                                                                                                                                 (JobStatus
                                                                                                                                    'Safe
                                                                                                                                    JobLog))
                                                                                                                           :<|> Handler
                                                                                                                                  (JobOutput
                                                                                                                                     JobLog)))))
                                                                                                  :<|> ((NodeId
                                                                                                         -> Handler
                                                                                                              (JobStatus
                                                                                                                 'Safe
                                                                                                                 JobLog)
                                                                                                            :<|> ((JobInput
                                                                                                                     Maybe
                                                                                                                     WithQuery
                                                                                                                   -> Handler
                                                                                                                        (JobStatus
                                                                                                                           'Safe
                                                                                                                           JobLog))
                                                                                                                  :<|> (ID
                                                                                                                          'Unsafe
                                                                                                                          "job"
                                                                                                                        -> (Maybe
                                                                                                                              Limit
                                                                                                                            -> Maybe
                                                                                                                                 Offset
                                                                                                                            -> Handler
                                                                                                                                 (JobStatus
                                                                                                                                    'Safe
                                                                                                                                    JobLog))
                                                                                                                           :<|> ((Maybe
                                                                                                                                    Limit
                                                                                                                                  -> Maybe
                                                                                                                                       Offset
                                                                                                                                  -> Handler
                                                                                                                                       (JobStatus
                                                                                                                                          'Safe
                                                                                                                                          JobLog))
                                                                                                                                 :<|> Handler
                                                                                                                                        (JobOutput
                                                                                                                                           JobLog)))))
                                                                                                        :<|> ((NodeId
                                                                                                               -> Handler
                                                                                                                    (Headers
                                                                                                                       '[Header
                                                                                                                           "Content-Disposition"
                                                                                                                           Text]
                                                                                                                       (Map
                                                                                                                          NgramsType
                                                                                                                          (Versioned
                                                                                                                             NgramsTableMap))))
                                                                                                              :<|> ((NodeId
                                                                                                                     -> Handler
                                                                                                                          (JobStatus
                                                                                                                             'Safe
                                                                                                                             JobLog)
                                                                                                                        :<|> ((JobInput
                                                                                                                                 Maybe
                                                                                                                                 WithFile
                                                                                                                               -> Handler
                                                                                                                                    (JobStatus
                                                                                                                                       'Safe
                                                                                                                                       JobLog))
                                                                                                                              :<|> (ID
                                                                                                                                      'Unsafe
                                                                                                                                      "job"
                                                                                                                                    -> (Maybe
                                                                                                                                          Limit
                                                                                                                                        -> Maybe
                                                                                                                                             Offset
                                                                                                                                        -> Handler
                                                                                                                                             (JobStatus
                                                                                                                                                'Safe
                                                                                                                                                JobLog))
                                                                                                                                       :<|> ((Maybe
                                                                                                                                                Limit
                                                                                                                                              -> Maybe
                                                                                                                                                   Offset
                                                                                                                                              -> Handler
                                                                                                                                                   (JobStatus
                                                                                                                                                      'Safe
                                                                                                                                                      JobLog))
                                                                                                                                             :<|> Handler
                                                                                                                                                    (JobOutput
                                                                                                                                                       JobLog)))))
                                                                                                                    :<|> (NodeId
                                                                                                                          -> Handler
                                                                                                                               (JobStatus
                                                                                                                                  'Safe
                                                                                                                                  JobLog)
                                                                                                                             :<|> ((JobInput
                                                                                                                                      Maybe
                                                                                                                                      WithTextFile
                                                                                                                                    -> Handler
                                                                                                                                         (JobStatus
                                                                                                                                            'Safe
                                                                                                                                            JobLog))
                                                                                                                                   :<|> (ID
                                                                                                                                           'Unsafe
                                                                                                                                           "job"
                                                                                                                                         -> (Maybe
                                                                                                                                               Limit
                                                                                                                                             -> Maybe
                                                                                                                                                  Offset
                                                                                                                                             -> Handler
                                                                                                                                                  (JobStatus
                                                                                                                                                     'Safe
                                                                                                                                                     JobLog))
                                                                                                                                            :<|> ((Maybe
                                                                                                                                                     Limit
                                                                                                                                                   -> Maybe
                                                                                                                                                        Offset
                                                                                                                                                   -> Handler
                                                                                                                                                        (JobStatus
                                                                                                                                                           'Safe
                                                                                                                                                           JobLog))
                                                                                                                                                  :<|> Handler
                                                                                                                                                         (JobOutput
                                                                                                                                                            JobLog))))))))))))))))))))
                            :<|> (Handler [PublicData]
                                  :<|> (NodeId
                                        -> Handler
                                             (Headers '[Header "Content-Type" Text] BSResponse))))))
               :<|> ((AuthResult AuthenticatedUser
                      -> (GQLRequest -> Handler GQLResponse) :<|> Handler ByteString)
                     :<|> Tagged Handler Application)))
forall a b. a -> b -> a :<|> b
:<|> (Handler Value
 :<|> (Handler
         (SwaggerUiHtml "swagger-ui" ("swagger.json" :> Get '[JSON] Value))
       :<|> (Handler
               (SwaggerUiHtml "swagger-ui" ("swagger.json" :> Get '[JSON] Value))
             :<|> Tagged Handler Application)))
:<|> (((AuthRequest -> Handler AuthResponse)
       :<|> (Handler Text
             :<|> ((AuthResult AuthenticatedUser
                    -> ((Handler [Node HyperdataUser] :<|> Handler Int)
                        :<|> ([NodeId] -> Handler Int))
                       :<|> ((NodeId
                              -> Handler
                                   (NodePoly
                                      NodeId
                                      (Maybe Text)
                                      Int
                                      Int
                                      (Maybe NodeId)
                                      Text
                                      UTCTime
                                      HyperdataAny)
                                 :<|> ((RenameNode -> Handler [Int])
                                       :<|> ((PostNode -> Handler [NodeId])
                                             :<|> ((Handler (JobStatus 'Safe JobLog)
                                                    :<|> ((JobInput Maybe PostNode
                                                           -> Handler (JobStatus 'Safe JobLog))
                                                          :<|> (ID 'Unsafe "job"
                                                                -> (Maybe Limit
                                                                    -> Maybe Offset
                                                                    -> Handler
                                                                         (JobStatus 'Safe JobLog))
                                                                   :<|> ((Maybe Limit
                                                                          -> Maybe Offset
                                                                          -> Handler
                                                                               (JobStatus
                                                                                  'Safe JobLog))
                                                                         :<|> Handler
                                                                                (JobOutput
                                                                                   JobLog)))))
                                                   :<|> ((Handler (JobStatus 'Safe JobLog)
                                                          :<|> ((JobInput Maybe FrameCalcUpload
                                                                 -> Handler
                                                                      (JobStatus 'Safe JobLog))
                                                                :<|> (ID 'Unsafe "job"
                                                                      -> (Maybe Limit
                                                                          -> Maybe Offset
                                                                          -> Handler
                                                                               (JobStatus
                                                                                  'Safe JobLog))
                                                                         :<|> ((Maybe Limit
                                                                                -> Maybe Offset
                                                                                -> Handler
                                                                                     (JobStatus
                                                                                        'Safe
                                                                                        JobLog))
                                                                               :<|> Handler
                                                                                      (JobOutput
                                                                                         JobLog)))))
                                                         :<|> ((HyperdataAny -> Handler Int)
                                                               :<|> ((Handler
                                                                        (JobStatus 'Safe JobLog)
                                                                      :<|> ((JobInput
                                                                               Maybe
                                                                               UpdateNodeParams
                                                                             -> Handler
                                                                                  (JobStatus
                                                                                     'Safe JobLog))
                                                                            :<|> (ID 'Unsafe "job"
                                                                                  -> (Maybe Limit
                                                                                      -> Maybe
                                                                                           Offset
                                                                                      -> Handler
                                                                                           (JobStatus
                                                                                              'Safe
                                                                                              JobLog))
                                                                                     :<|> ((Maybe
                                                                                              Limit
                                                                                            -> Maybe
                                                                                                 Offset
                                                                                            -> Handler
                                                                                                 (JobStatus
                                                                                                    'Safe
                                                                                                    JobLog))
                                                                                           :<|> Handler
                                                                                                  (JobOutput
                                                                                                     JobLog)))))
                                                                     :<|> (Handler Int
                                                                           :<|> ((Maybe NodeType
                                                                                  -> Maybe Int
                                                                                  -> Maybe Int
                                                                                  -> Handler
                                                                                       (TableResult
                                                                                          (NodePoly
                                                                                             NodeId
                                                                                             (Maybe
                                                                                                Text)
                                                                                             Int
                                                                                             Int
                                                                                             (Maybe
                                                                                                NodeId)
                                                                                             Text
                                                                                             UTCTime
                                                                                             HyperdataAny)))
                                                                                 :<|> (((Maybe
                                                                                           TabType
                                                                                         -> Maybe
                                                                                              NodeId
                                                                                         -> Maybe
                                                                                              Int
                                                                                         -> Maybe
                                                                                              Int
                                                                                         -> Maybe
                                                                                              OrderBy
                                                                                         -> Maybe
                                                                                              Text
                                                                                         -> Handler
                                                                                              (HashedResponse
                                                                                                 FacetTableResult))
                                                                                        :<|> ((TableQuery
                                                                                               -> Handler
                                                                                                    FacetTableResult)
                                                                                              :<|> (Maybe
                                                                                                      TabType
                                                                                                    -> Handler
                                                                                                         Text)))
                                                                                       :<|> (((TabType
                                                                                               -> NodeId
                                                                                               -> Int
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    ListType
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    OrderBy
                                                                                               -> Maybe
                                                                                                    Text
                                                                                               -> Handler
                                                                                                    (VersionedWithCount
                                                                                                       NgramsTable))
                                                                                              :<|> ((TabType
                                                                                                     -> NodeId
                                                                                                     -> Versioned
                                                                                                          NgramsTablePatch
                                                                                                     -> Handler
                                                                                                          (Versioned
                                                                                                             NgramsTablePatch))
                                                                                                    :<|> ((TabType
                                                                                                           -> NodeId
                                                                                                           -> Handler
                                                                                                                Int)
                                                                                                          :<|> ((TabType
                                                                                                                 -> NodeId
                                                                                                                 -> Handler
                                                                                                                      Int)
                                                                                                                :<|> (Handler
                                                                                                                        (JobStatus
                                                                                                                           'Safe
                                                                                                                           JobLog)
                                                                                                                      :<|> ((JobInput
                                                                                                                               Maybe
                                                                                                                               UpdateTableNgramsCharts
                                                                                                                             -> Handler
                                                                                                                                  (JobStatus
                                                                                                                                     'Safe
                                                                                                                                     JobLog))
                                                                                                                            :<|> (ID
                                                                                                                                    'Unsafe
                                                                                                                                    "job"
                                                                                                                                  -> (Maybe
                                                                                                                                        Limit
                                                                                                                                      -> Maybe
                                                                                                                                           Offset
                                                                                                                                      -> Handler
                                                                                                                                           (JobStatus
                                                                                                                                              'Safe
                                                                                                                                              JobLog))
                                                                                                                                     :<|> ((Maybe
                                                                                                                                              Limit
                                                                                                                                            -> Maybe
                                                                                                                                                 Offset
                                                                                                                                            -> Handler
                                                                                                                                                 (JobStatus
                                                                                                                                                    'Safe
                                                                                                                                                    JobLog))
                                                                                                                                           :<|> Handler
                                                                                                                                                  (JobOutput
                                                                                                                                                     JobLog)))))))))
                                                                                             :<|> ((NodesToCategory
                                                                                                    -> Handler
                                                                                                         [Int])
                                                                                                   :<|> ((NodesToScore
                                                                                                          -> Handler
                                                                                                               [Int])
                                                                                                         :<|> ((SearchQuery
                                                                                                                -> Maybe
                                                                                                                     Int
                                                                                                                -> Maybe
                                                                                                                     Int
                                                                                                                -> Maybe
                                                                                                                     OrderBy
                                                                                                                -> Handler
                                                                                                                     SearchResult)
                                                                                                               :<|> ((ShareNodeParams
                                                                                                                      -> Handler
                                                                                                                           Int)
                                                                                                                     :<|> ((NodeId
                                                                                                                            -> Maybe
                                                                                                                                 NodeId
                                                                                                                            -> Handler
                                                                                                                                 Int)
                                                                                                                           :<|> (Handler
                                                                                                                                   [NodeId]
                                                                                                                                 :<|> ((Maybe
                                                                                                                                          TabType
                                                                                                                                        -> Maybe
                                                                                                                                             Int
                                                                                                                                        -> Maybe
                                                                                                                                             Int
                                                                                                                                        -> Maybe
                                                                                                                                             OrderBy
                                                                                                                                        -> Handler
                                                                                                                                             [FacetDoc])
                                                                                                                                       :<|> (((Maybe
                                                                                                                                                 NodeId
                                                                                                                                               -> TabType
                                                                                                                                               -> Maybe
                                                                                                                                                    Int
                                                                                                                                               -> Handler
                                                                                                                                                    (HashedResponse
                                                                                                                                                       Metrics))
                                                                                                                                              :<|> ((Maybe
                                                                                                                                                       NodeId
                                                                                                                                                     -> TabType
                                                                                                                                                     -> Maybe
                                                                                                                                                          Int
                                                                                                                                                     -> Handler
                                                                                                                                                          ())
                                                                                                                                                    :<|> (Maybe
                                                                                                                                                            NodeId
                                                                                                                                                          -> TabType
                                                                                                                                                          -> Handler
                                                                                                                                                               Text)))
                                                                                                                                             :<|> (((Maybe
                                                                                                                                                       UTCTime
                                                                                                                                                     -> Maybe
                                                                                                                                                          UTCTime
                                                                                                                                                     -> Maybe
                                                                                                                                                          NodeId
                                                                                                                                                     -> TabType
                                                                                                                                                     -> Handler
                                                                                                                                                          (HashedResponse
                                                                                                                                                             (ChartMetrics
                                                                                                                                                                Histo)))
                                                                                                                                                    :<|> ((Maybe
                                                                                                                                                             NodeId
                                                                                                                                                           -> TabType
                                                                                                                                                           -> Maybe
                                                                                                                                                                Int
                                                                                                                                                           -> Handler
                                                                                                                                                                ())
                                                                                                                                                          :<|> (Maybe
                                                                                                                                                                  NodeId
                                                                                                                                                                -> TabType
                                                                                                                                                                -> Handler
                                                                                                                                                                     Text)))
                                                                                                                                                   :<|> (((Maybe
                                                                                                                                                             UTCTime
                                                                                                                                                           -> Maybe
                                                                                                                                                                UTCTime
                                                                                                                                                           -> Maybe
                                                                                                                                                                NodeId
                                                                                                                                                           -> TabType
                                                                                                                                                           -> Handler
                                                                                                                                                                (HashedResponse
                                                                                                                                                                   (ChartMetrics
                                                                                                                                                                      Histo)))
                                                                                                                                                          :<|> ((Maybe
                                                                                                                                                                   NodeId
                                                                                                                                                                 -> TabType
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      Int
                                                                                                                                                                 -> Handler
                                                                                                                                                                      ())
                                                                                                                                                                :<|> (Maybe
                                                                                                                                                                        NodeId
                                                                                                                                                                      -> TabType
                                                                                                                                                                      -> Handler
                                                                                                                                                                           Text)))
                                                                                                                                                         :<|> (((Maybe
                                                                                                                                                                   UTCTime
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      UTCTime
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      NodeId
                                                                                                                                                                 -> TabType
                                                                                                                                                                 -> ListType
                                                                                                                                                                 -> Handler
                                                                                                                                                                      (HashedResponse
                                                                                                                                                                         (ChartMetrics
                                                                                                                                                                            (Vector
                                                                                                                                                                               NgramsTree))))
                                                                                                                                                                :<|> ((Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                       -> TabType
                                                                                                                                                                       -> ListType
                                                                                                                                                                       -> Handler
                                                                                                                                                                            ())
                                                                                                                                                                      :<|> (Maybe
                                                                                                                                                                              NodeId
                                                                                                                                                                            -> TabType
                                                                                                                                                                            -> ListType
                                                                                                                                                                            -> Handler
                                                                                                                                                                                 Text)))
                                                                                                                                                               :<|> (((Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            Int
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            Int
                                                                                                                                                                       -> Handler
                                                                                                                                                                            SVG)
                                                                                                                                                                      :<|> (Maybe
                                                                                                                                                                              NodeId
                                                                                                                                                                            -> Handler
                                                                                                                                                                                 NodeId))
                                                                                                                                                                     :<|> ((NodeId
                                                                                                                                                                            -> Handler
                                                                                                                                                                                 [Int])
                                                                                                                                                                           :<|> ((NodeId
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       Int)
                                                                                                                                                                                 :<|> (Handler
                                                                                                                                                                                         (Headers
                                                                                                                                                                                            '[Header
                                                                                                                                                                                                "Content-Type"
                                                                                                                                                                                                Text]
                                                                                                                                                                                            BSResponse)
                                                                                                                                                                                       :<|> ((Handler
                                                                                                                                                                                                (JobStatus
                                                                                                                                                                                                   'Safe
                                                                                                                                                                                                   JobLog)
                                                                                                                                                                                              :<|> ((JobInput
                                                                                                                                                                                                       Maybe
                                                                                                                                                                                                       NewWithFile
                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                             JobLog))
                                                                                                                                                                                                    :<|> (ID
                                                                                                                                                                                                            'Unsafe
                                                                                                                                                                                                            "job"
                                                                                                                                                                                                          -> (Maybe
                                                                                                                                                                                                                Limit
                                                                                                                                                                                                              -> Maybe
                                                                                                                                                                                                                   Offset
                                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                                   (JobStatus
                                                                                                                                                                                                                      'Safe
                                                                                                                                                                                                                      JobLog))
                                                                                                                                                                                                             :<|> ((Maybe
                                                                                                                                                                                                                      Limit
                                                                                                                                                                                                                    -> Maybe
                                                                                                                                                                                                                         Offset
                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                   :<|> Handler
                                                                                                                                                                                                                          (JobOutput
                                                                                                                                                                                                                             JobLog)))))
                                                                                                                                                                                             :<|> ((Handler
                                                                                                                                                                                                      (JobStatus
                                                                                                                                                                                                         'Safe
                                                                                                                                                                                                         JobLog)
                                                                                                                                                                                                    :<|> ((JobInput
                                                                                                                                                                                                             Maybe
                                                                                                                                                                                                             Params
                                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                                (JobStatus
                                                                                                                                                                                                                   'Safe
                                                                                                                                                                                                                   JobLog))
                                                                                                                                                                                                          :<|> (ID
                                                                                                                                                                                                                  'Unsafe
                                                                                                                                                                                                                  "job"
                                                                                                                                                                                                                -> (Maybe
                                                                                                                                                                                                                      Limit
                                                                                                                                                                                                                    -> Maybe
                                                                                                                                                                                                                         Offset
                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                   :<|> ((Maybe
                                                                                                                                                                                                                            Limit
                                                                                                                                                                                                                          -> Maybe
                                                                                                                                                                                                                               Offset
                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                         :<|> Handler
                                                                                                                                                                                                                                (JobOutput
                                                                                                                                                                                                                                   JobLog)))))
                                                                                                                                                                                                   :<|> (Handler
                                                                                                                                                                                                           (JobStatus
                                                                                                                                                                                                              'Safe
                                                                                                                                                                                                              JobLog)
                                                                                                                                                                                                         :<|> ((JobInput
                                                                                                                                                                                                                  Maybe
                                                                                                                                                                                                                  DocumentUpload
                                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                                     (JobStatus
                                                                                                                                                                                                                        'Safe
                                                                                                                                                                                                                        JobLog))
                                                                                                                                                                                                               :<|> (ID
                                                                                                                                                                                                                       'Unsafe
                                                                                                                                                                                                                       "job"
                                                                                                                                                                                                                     -> (Maybe
                                                                                                                                                                                                                           Limit
                                                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                                                              Offset
                                                                                                                                                                                                                         -> Handler
                                                                                                                                                                                                                              (JobStatus
                                                                                                                                                                                                                                 'Safe
                                                                                                                                                                                                                                 JobLog))
                                                                                                                                                                                                                        :<|> ((Maybe
                                                                                                                                                                                                                                 Limit
                                                                                                                                                                                                                               -> Maybe
                                                                                                                                                                                                                                    Offset
                                                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                                                       JobLog))
                                                                                                                                                                                                                              :<|> Handler
                                                                                                                                                                                                                                     (JobOutput
                                                                                                                                                                                                                                        JobLog)))))))))))))))))))))))))))))))))
                             :<|> ((NodeId
                                    -> Handler
                                         (NodePoly
                                            NodeId
                                            (Maybe Text)
                                            Int
                                            Int
                                            (Maybe NodeId)
                                            Text
                                            UTCTime
                                            HyperdataCorpus)
                                       :<|> ((RenameNode -> Handler [Int])
                                             :<|> ((PostNode -> Handler [NodeId])
                                                   :<|> ((Handler (JobStatus 'Safe JobLog)
                                                          :<|> ((JobInput Maybe PostNode
                                                                 -> Handler
                                                                      (JobStatus 'Safe JobLog))
                                                                :<|> (ID 'Unsafe "job"
                                                                      -> (Maybe Limit
                                                                          -> Maybe Offset
                                                                          -> Handler
                                                                               (JobStatus
                                                                                  'Safe JobLog))
                                                                         :<|> ((Maybe Limit
                                                                                -> Maybe Offset
                                                                                -> Handler
                                                                                     (JobStatus
                                                                                        'Safe
                                                                                        JobLog))
                                                                               :<|> Handler
                                                                                      (JobOutput
                                                                                         JobLog)))))
                                                         :<|> ((Handler (JobStatus 'Safe JobLog)
                                                                :<|> ((JobInput
                                                                         Maybe FrameCalcUpload
                                                                       -> Handler
                                                                            (JobStatus
                                                                               'Safe JobLog))
                                                                      :<|> (ID 'Unsafe "job"
                                                                            -> (Maybe Limit
                                                                                -> Maybe Offset
                                                                                -> Handler
                                                                                     (JobStatus
                                                                                        'Safe
                                                                                        JobLog))
                                                                               :<|> ((Maybe Limit
                                                                                      -> Maybe
                                                                                           Offset
                                                                                      -> Handler
                                                                                           (JobStatus
                                                                                              'Safe
                                                                                              JobLog))
                                                                                     :<|> Handler
                                                                                            (JobOutput
                                                                                               JobLog)))))
                                                               :<|> ((HyperdataCorpus
                                                                      -> Handler Int)
                                                                     :<|> ((Handler
                                                                              (JobStatus
                                                                                 'Safe JobLog)
                                                                            :<|> ((JobInput
                                                                                     Maybe
                                                                                     UpdateNodeParams
                                                                                   -> Handler
                                                                                        (JobStatus
                                                                                           'Safe
                                                                                           JobLog))
                                                                                  :<|> (ID
                                                                                          'Unsafe
                                                                                          "job"
                                                                                        -> (Maybe
                                                                                              Limit
                                                                                            -> Maybe
                                                                                                 Offset
                                                                                            -> Handler
                                                                                                 (JobStatus
                                                                                                    'Safe
                                                                                                    JobLog))
                                                                                           :<|> ((Maybe
                                                                                                    Limit
                                                                                                  -> Maybe
                                                                                                       Offset
                                                                                                  -> Handler
                                                                                                       (JobStatus
                                                                                                          'Safe
                                                                                                          JobLog))
                                                                                                 :<|> Handler
                                                                                                        (JobOutput
                                                                                                           JobLog)))))
                                                                           :<|> (Handler Int
                                                                                 :<|> ((Maybe
                                                                                          NodeType
                                                                                        -> Maybe Int
                                                                                        -> Maybe Int
                                                                                        -> Handler
                                                                                             (TableResult
                                                                                                (NodePoly
                                                                                                   NodeId
                                                                                                   (Maybe
                                                                                                      Text)
                                                                                                   Int
                                                                                                   Int
                                                                                                   (Maybe
                                                                                                      NodeId)
                                                                                                   Text
                                                                                                   UTCTime
                                                                                                   HyperdataCorpus)))
                                                                                       :<|> (((Maybe
                                                                                                 TabType
                                                                                               -> Maybe
                                                                                                    NodeId
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    Int
                                                                                               -> Maybe
                                                                                                    OrderBy
                                                                                               -> Maybe
                                                                                                    Text
                                                                                               -> Handler
                                                                                                    (HashedResponse
                                                                                                       FacetTableResult))
                                                                                              :<|> ((TableQuery
                                                                                                     -> Handler
                                                                                                          FacetTableResult)
                                                                                                    :<|> (Maybe
                                                                                                            TabType
                                                                                                          -> Handler
                                                                                                               Text)))
                                                                                             :<|> (((TabType
                                                                                                     -> NodeId
                                                                                                     -> Int
                                                                                                     -> Maybe
                                                                                                          Int
                                                                                                     -> Maybe
                                                                                                          ListType
                                                                                                     -> Maybe
                                                                                                          Int
                                                                                                     -> Maybe
                                                                                                          Int
                                                                                                     -> Maybe
                                                                                                          OrderBy
                                                                                                     -> Maybe
                                                                                                          Text
                                                                                                     -> Handler
                                                                                                          (VersionedWithCount
                                                                                                             NgramsTable))
                                                                                                    :<|> ((TabType
                                                                                                           -> NodeId
                                                                                                           -> Versioned
                                                                                                                NgramsTablePatch
                                                                                                           -> Handler
                                                                                                                (Versioned
                                                                                                                   NgramsTablePatch))
                                                                                                          :<|> ((TabType
                                                                                                                 -> NodeId
                                                                                                                 -> Handler
                                                                                                                      Int)
                                                                                                                :<|> ((TabType
                                                                                                                       -> NodeId
                                                                                                                       -> Handler
                                                                                                                            Int)
                                                                                                                      :<|> (Handler
                                                                                                                              (JobStatus
                                                                                                                                 'Safe
                                                                                                                                 JobLog)
                                                                                                                            :<|> ((JobInput
                                                                                                                                     Maybe
                                                                                                                                     UpdateTableNgramsCharts
                                                                                                                                   -> Handler
                                                                                                                                        (JobStatus
                                                                                                                                           'Safe
                                                                                                                                           JobLog))
                                                                                                                                  :<|> (ID
                                                                                                                                          'Unsafe
                                                                                                                                          "job"
                                                                                                                                        -> (Maybe
                                                                                                                                              Limit
                                                                                                                                            -> Maybe
                                                                                                                                                 Offset
                                                                                                                                            -> Handler
                                                                                                                                                 (JobStatus
                                                                                                                                                    'Safe
                                                                                                                                                    JobLog))
                                                                                                                                           :<|> ((Maybe
                                                                                                                                                    Limit
                                                                                                                                                  -> Maybe
                                                                                                                                                       Offset
                                                                                                                                                  -> Handler
                                                                                                                                                       (JobStatus
                                                                                                                                                          'Safe
                                                                                                                                                          JobLog))
                                                                                                                                                 :<|> Handler
                                                                                                                                                        (JobOutput
                                                                                                                                                           JobLog)))))))))
                                                                                                   :<|> ((NodesToCategory
                                                                                                          -> Handler
                                                                                                               [Int])
                                                                                                         :<|> ((NodesToScore
                                                                                                                -> Handler
                                                                                                                     [Int])
                                                                                                               :<|> ((SearchQuery
                                                                                                                      -> Maybe
                                                                                                                           Int
                                                                                                                      -> Maybe
                                                                                                                           Int
                                                                                                                      -> Maybe
                                                                                                                           OrderBy
                                                                                                                      -> Handler
                                                                                                                           SearchResult)
                                                                                                                     :<|> ((ShareNodeParams
                                                                                                                            -> Handler
                                                                                                                                 Int)
                                                                                                                           :<|> ((NodeId
                                                                                                                                  -> Maybe
                                                                                                                                       NodeId
                                                                                                                                  -> Handler
                                                                                                                                       Int)
                                                                                                                                 :<|> (Handler
                                                                                                                                         [NodeId]
                                                                                                                                       :<|> ((Maybe
                                                                                                                                                TabType
                                                                                                                                              -> Maybe
                                                                                                                                                   Int
                                                                                                                                              -> Maybe
                                                                                                                                                   Int
                                                                                                                                              -> Maybe
                                                                                                                                                   OrderBy
                                                                                                                                              -> Handler
                                                                                                                                                   [FacetDoc])
                                                                                                                                             :<|> (((Maybe
                                                                                                                                                       NodeId
                                                                                                                                                     -> TabType
                                                                                                                                                     -> Maybe
                                                                                                                                                          Int
                                                                                                                                                     -> Handler
                                                                                                                                                          (HashedResponse
                                                                                                                                                             Metrics))
                                                                                                                                                    :<|> ((Maybe
                                                                                                                                                             NodeId
                                                                                                                                                           -> TabType
                                                                                                                                                           -> Maybe
                                                                                                                                                                Int
                                                                                                                                                           -> Handler
                                                                                                                                                                ())
                                                                                                                                                          :<|> (Maybe
                                                                                                                                                                  NodeId
                                                                                                                                                                -> TabType
                                                                                                                                                                -> Handler
                                                                                                                                                                     Text)))
                                                                                                                                                   :<|> (((Maybe
                                                                                                                                                             UTCTime
                                                                                                                                                           -> Maybe
                                                                                                                                                                UTCTime
                                                                                                                                                           -> Maybe
                                                                                                                                                                NodeId
                                                                                                                                                           -> TabType
                                                                                                                                                           -> Handler
                                                                                                                                                                (HashedResponse
                                                                                                                                                                   (ChartMetrics
                                                                                                                                                                      Histo)))
                                                                                                                                                          :<|> ((Maybe
                                                                                                                                                                   NodeId
                                                                                                                                                                 -> TabType
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      Int
                                                                                                                                                                 -> Handler
                                                                                                                                                                      ())
                                                                                                                                                                :<|> (Maybe
                                                                                                                                                                        NodeId
                                                                                                                                                                      -> TabType
                                                                                                                                                                      -> Handler
                                                                                                                                                                           Text)))
                                                                                                                                                         :<|> (((Maybe
                                                                                                                                                                   UTCTime
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      UTCTime
                                                                                                                                                                 -> Maybe
                                                                                                                                                                      NodeId
                                                                                                                                                                 -> TabType
                                                                                                                                                                 -> Handler
                                                                                                                                                                      (HashedResponse
                                                                                                                                                                         (ChartMetrics
                                                                                                                                                                            Histo)))
                                                                                                                                                                :<|> ((Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                       -> TabType
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            Int
                                                                                                                                                                       -> Handler
                                                                                                                                                                            ())
                                                                                                                                                                      :<|> (Maybe
                                                                                                                                                                              NodeId
                                                                                                                                                                            -> TabType
                                                                                                                                                                            -> Handler
                                                                                                                                                                                 Text)))
                                                                                                                                                               :<|> (((Maybe
                                                                                                                                                                         UTCTime
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            UTCTime
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            NodeId
                                                                                                                                                                       -> TabType
                                                                                                                                                                       -> ListType
                                                                                                                                                                       -> Handler
                                                                                                                                                                            (HashedResponse
                                                                                                                                                                               (ChartMetrics
                                                                                                                                                                                  (Vector
                                                                                                                                                                                     NgramsTree))))
                                                                                                                                                                      :<|> ((Maybe
                                                                                                                                                                               NodeId
                                                                                                                                                                             -> TabType
                                                                                                                                                                             -> ListType
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  ())
                                                                                                                                                                            :<|> (Maybe
                                                                                                                                                                                    NodeId
                                                                                                                                                                                  -> TabType
                                                                                                                                                                                  -> ListType
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       Text)))
                                                                                                                                                                     :<|> (((Maybe
                                                                                                                                                                               NodeId
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  Int
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  Int
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  SVG)
                                                                                                                                                                            :<|> (Maybe
                                                                                                                                                                                    NodeId
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       NodeId))
                                                                                                                                                                           :<|> ((NodeId
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       [Int])
                                                                                                                                                                                 :<|> ((NodeId
                                                                                                                                                                                        -> Handler
                                                                                                                                                                                             Int)
                                                                                                                                                                                       :<|> (Handler
                                                                                                                                                                                               (Headers
                                                                                                                                                                                                  '[Header
                                                                                                                                                                                                      "Content-Type"
                                                                                                                                                                                                      Text]
                                                                                                                                                                                                  BSResponse)
                                                                                                                                                                                             :<|> ((Handler
                                                                                                                                                                                                      (JobStatus
                                                                                                                                                                                                         'Safe
                                                                                                                                                                                                         JobLog)
                                                                                                                                                                                                    :<|> ((JobInput
                                                                                                                                                                                                             Maybe
                                                                                                                                                                                                             NewWithFile
                                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                                (JobStatus
                                                                                                                                                                                                                   'Safe
                                                                                                                                                                                                                   JobLog))
                                                                                                                                                                                                          :<|> (ID
                                                                                                                                                                                                                  'Unsafe
                                                                                                                                                                                                                  "job"
                                                                                                                                                                                                                -> (Maybe
                                                                                                                                                                                                                      Limit
                                                                                                                                                                                                                    -> Maybe
                                                                                                                                                                                                                         Offset
                                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                                         (JobStatus
                                                                                                                                                                                                                            'Safe
                                                                                                                                                                                                                            JobLog))
                                                                                                                                                                                                                   :<|> ((Maybe
                                                                                                                                                                                                                            Limit
                                                                                                                                                                                                                          -> Maybe
                                                                                                                                                                                                                               Offset
                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                         :<|> Handler
                                                                                                                                                                                                                                (JobOutput
                                                                                                                                                                                                                                   JobLog)))))
                                                                                                                                                                                                   :<|> ((Handler
                                                                                                                                                                                                            (JobStatus
                                                                                                                                                                                                               'Safe
                                                                                                                                                                                                               JobLog)
                                                                                                                                                                                                          :<|> ((JobInput
                                                                                                                                                                                                                   Maybe
                                                                                                                                                                                                                   Params
                                                                                                                                                                                                                 -> Handler
                                                                                                                                                                                                                      (JobStatus
                                                                                                                                                                                                                         'Safe
                                                                                                                                                                                                                         JobLog))
                                                                                                                                                                                                                :<|> (ID
                                                                                                                                                                                                                        'Unsafe
                                                                                                                                                                                                                        "job"
                                                                                                                                                                                                                      -> (Maybe
                                                                                                                                                                                                                            Limit
                                                                                                                                                                                                                          -> Maybe
                                                                                                                                                                                                                               Offset
                                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                                               (JobStatus
                                                                                                                                                                                                                                  'Safe
                                                                                                                                                                                                                                  JobLog))
                                                                                                                                                                                                                         :<|> ((Maybe
                                                                                                                                                                                                                                  Limit
                                                                                                                                                                                                                                -> Maybe
                                                                                                                                                                                                                                     Offset
                                                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                                                     (JobStatus
                                                                                                                                                                                                                                        'Safe
                                                                                                                                                                                                                                        JobLog))
                                                                                                                                                                                                                               :<|> Handler
                                                                                                                                                                                                                                      (JobOutput
                                                                                                                                                                                                                                         JobLog)))))
                                                                                                                                                                                                         :<|> (Handler
                                                                                                                                                                                                                 (JobStatus
                                                                                                                                                                                                                    'Safe
                                                                                                                                                                                                                    JobLog)
                                                                                                                                                                                                               :<|> ((JobInput
                                                                                                                                                                                                                        Maybe
                                                                                                                                                                                                                        DocumentUpload
                                                                                                                                                                                                                      -> Handler
                                                                                                                                                                                                                           (JobStatus
                                                                                                                                                                                                                              'Safe
                                                                                                                                                                                                                              JobLog))
                                                                                                                                                                                                                     :<|> (ID
                                                                                                                                                                                                                             'Unsafe
                                                                                                                                                                                                                             "job"
                                                                                                                                                                                                                           -> (Maybe
                                                                                                                                                                                                                                 Limit
                                                                                                                                                                                                                               -> Maybe
                                                                                                                                                                                                                                    Offset
                                                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                                                    (JobStatus
                                                                                                                                                                                                                                       'Safe
                                                                                                                                                                                                                                       JobLog))
                                                                                                                                                                                                                              :<|> ((Maybe
                                                                                                                                                                                                                                       Limit
                                                                                                                                                                                                                                     -> Maybe
                                                                                                                                                                                                                                          Offset
                                                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                                                          (JobStatus
                                                                                                                                                                                                                                             'Safe
                                                                                                                                                                                                                                             JobLog))
                                                                                                                                                                                                                                    :<|> Handler
                                                                                                                                                                                                                                           (JobOutput
                                                                                                                                                                                                                                              JobLog)))))))))))))))))))))))))))))))))
                                   :<|> ((NodeId
                                          -> NodeId
                                          -> Handler
                                               (NodePoly
                                                  NodeId
                                                  (Maybe Text)
                                                  Int
                                                  Int
                                                  (Maybe NodeId)
                                                  Text
                                                  UTCTime
                                                  HyperdataAny))
                                         :<|> ((NodeId
                                                -> Maybe NodeId
                                                -> Maybe NgramsType
                                                -> Handler Corpus)
                                               :<|> ((NodeId
                                                      -> Handler
                                                           (NodePoly
                                                              NodeId
                                                              (Maybe Text)
                                                              Int
                                                              Int
                                                              (Maybe NodeId)
                                                              Text
                                                              UTCTime
                                                              HyperdataAnnuaire)
                                                         :<|> ((RenameNode -> Handler [Int])
                                                               :<|> ((PostNode -> Handler [NodeId])
                                                                     :<|> ((Handler
                                                                              (JobStatus
                                                                                 'Safe JobLog)
                                                                            :<|> ((JobInput
                                                                                     Maybe PostNode
                                                                                   -> Handler
                                                                                        (JobStatus
                                                                                           'Safe
                                                                                           JobLog))
                                                                                  :<|> (ID
                                                                                          'Unsafe
                                                                                          "job"
                                                                                        -> (Maybe
                                                                                              Limit
                                                                                            -> Maybe
                                                                                                 Offset
                                                                                            -> Handler
                                                                                                 (JobStatus
                                                                                                    'Safe
                                                                                                    JobLog))
                                                                                           :<|> ((Maybe
                                                                                                    Limit
                                                                                                  -> Maybe
                                                                                                       Offset
                                                                                                  -> Handler
                                                                                                       (JobStatus
                                                                                                          'Safe
                                                                                                          JobLog))
                                                                                                 :<|> Handler
                                                                                                        (JobOutput
                                                                                                           JobLog)))))
                                                                           :<|> ((Handler
                                                                                    (JobStatus
                                                                                       'Safe JobLog)
                                                                                  :<|> ((JobInput
                                                                                           Maybe
                                                                                           FrameCalcUpload
                                                                                         -> Handler
                                                                                              (JobStatus
                                                                                                 'Safe
                                                                                                 JobLog))
                                                                                        :<|> (ID
                                                                                                'Unsafe
                                                                                                "job"
                                                                                              -> (Maybe
                                                                                                    Limit
                                                                                                  -> Maybe
                                                                                                       Offset
                                                                                                  -> Handler
                                                                                                       (JobStatus
                                                                                                          'Safe
                                                                                                          JobLog))
                                                                                                 :<|> ((Maybe
                                                                                                          Limit
                                                                                                        -> Maybe
                                                                                                             Offset
                                                                                                        -> Handler
                                                                                                             (JobStatus
                                                                                                                'Safe
                                                                                                                JobLog))
                                                                                                       :<|> Handler
                                                                                                              (JobOutput
                                                                                                                 JobLog)))))
                                                                                 :<|> ((HyperdataAnnuaire
                                                                                        -> Handler
                                                                                             Int)
                                                                                       :<|> ((Handler
                                                                                                (JobStatus
                                                                                                   'Safe
                                                                                                   JobLog)
                                                                                              :<|> ((JobInput
                                                                                                       Maybe
                                                                                                       UpdateNodeParams
                                                                                                     -> Handler
                                                                                                          (JobStatus
                                                                                                             'Safe
                                                                                                             JobLog))
                                                                                                    :<|> (ID
                                                                                                            'Unsafe
                                                                                                            "job"
                                                                                                          -> (Maybe
                                                                                                                Limit
                                                                                                              -> Maybe
                                                                                                                   Offset
                                                                                                              -> Handler
                                                                                                                   (JobStatus
                                                                                                                      'Safe
                                                                                                                      JobLog))
                                                                                                             :<|> ((Maybe
                                                                                                                      Limit
                                                                                                                    -> Maybe
                                                                                                                         Offset
                                                                                                                    -> Handler
                                                                                                                         (JobStatus
                                                                                                                            'Safe
                                                                                                                            JobLog))
                                                                                                                   :<|> Handler
                                                                                                                          (JobOutput
                                                                                                                             JobLog)))))
                                                                                             :<|> (Handler
                                                                                                     Int
                                                                                                   :<|> ((Maybe
                                                                                                            NodeType
                                                                                                          -> Maybe
                                                                                                               Int
                                                                                                          -> Maybe
                                                                                                               Int
                                                                                                          -> Handler
                                                                                                               (TableResult
                                                                                                                  (NodePoly
                                                                                                                     NodeId
                                                                                                                     (Maybe
                                                                                                                        Text)
                                                                                                                     Int
                                                                                                                     Int
                                                                                                                     (Maybe
                                                                                                                        NodeId)
                                                                                                                     Text
                                                                                                                     UTCTime
                                                                                                                     HyperdataAnnuaire)))
                                                                                                         :<|> (((Maybe
                                                                                                                   TabType
                                                                                                                 -> Maybe
                                                                                                                      NodeId
                                                                                                                 -> Maybe
                                                                                                                      Int
                                                                                                                 -> Maybe
                                                                                                                      Int
                                                                                                                 -> Maybe
                                                                                                                      OrderBy
                                                                                                                 -> Maybe
                                                                                                                      Text
                                                                                                                 -> Handler
                                                                                                                      (HashedResponse
                                                                                                                         FacetTableResult))
                                                                                                                :<|> ((TableQuery
                                                                                                                       -> Handler
                                                                                                                            FacetTableResult)
                                                                                                                      :<|> (Maybe
                                                                                                                              TabType
                                                                                                                            -> Handler
                                                                                                                                 Text)))
                                                                                                               :<|> (((TabType
                                                                                                                       -> NodeId
                                                                                                                       -> Int
                                                                                                                       -> Maybe
                                                                                                                            Int
                                                                                                                       -> Maybe
                                                                                                                            ListType
                                                                                                                       -> Maybe
                                                                                                                            Int
                                                                                                                       -> Maybe
                                                                                                                            Int
                                                                                                                       -> Maybe
                                                                                                                            OrderBy
                                                                                                                       -> Maybe
                                                                                                                            Text
                                                                                                                       -> Handler
                                                                                                                            (VersionedWithCount
                                                                                                                               NgramsTable))
                                                                                                                      :<|> ((TabType
                                                                                                                             -> NodeId
                                                                                                                             -> Versioned
                                                                                                                                  NgramsTablePatch
                                                                                                                             -> Handler
                                                                                                                                  (Versioned
                                                                                                                                     NgramsTablePatch))
                                                                                                                            :<|> ((TabType
                                                                                                                                   -> NodeId
                                                                                                                                   -> Handler
                                                                                                                                        Int)
                                                                                                                                  :<|> ((TabType
                                                                                                                                         -> NodeId
                                                                                                                                         -> Handler
                                                                                                                                              Int)
                                                                                                                                        :<|> (Handler
                                                                                                                                                (JobStatus
                                                                                                                                                   'Safe
                                                                                                                                                   JobLog)
                                                                                                                                              :<|> ((JobInput
                                                                                                                                                       Maybe
                                                                                                                                                       UpdateTableNgramsCharts
                                                                                                                                                     -> Handler
                                                                                                                                                          (JobStatus
                                                                                                                                                             'Safe
                                                                                                                                                             JobLog))
                                                                                                                                                    :<|> (ID
                                                                                                                                                            'Unsafe
                                                                                                                                                            "job"
                                                                                                                                                          -> (Maybe
                                                                                                                                                                Limit
                                                                                                                                                              -> Maybe
                                                                                                                                                                   Offset
                                                                                                                                                              -> Handler
                                                                                                                                                                   (JobStatus
                                                                                                                                                                      'Safe
                                                                                                                                                                      JobLog))
                                                                                                                                                             :<|> ((Maybe
                                                                                                                                                                      Limit
                                                                                                                                                                    -> Maybe
                                                                                                                                                                         Offset
                                                                                                                                                                    -> Handler
                                                                                                                                                                         (JobStatus
                                                                                                                                                                            'Safe
                                                                                                                                                                            JobLog))
                                                                                                                                                                   :<|> Handler
                                                                                                                                                                          (JobOutput
                                                                                                                                                                             JobLog)))))))))
                                                                                                                     :<|> ((NodesToCategory
                                                                                                                            -> Handler
                                                                                                                                 [Int])
                                                                                                                           :<|> ((NodesToScore
                                                                                                                                  -> Handler
                                                                                                                                       [Int])
                                                                                                                                 :<|> ((SearchQuery
                                                                                                                                        -> Maybe
                                                                                                                                             Int
                                                                                                                                        -> Maybe
                                                                                                                                             Int
                                                                                                                                        -> Maybe
                                                                                                                                             OrderBy
                                                                                                                                        -> Handler
                                                                                                                                             SearchResult)
                                                                                                                                       :<|> ((ShareNodeParams
                                                                                                                                              -> Handler
                                                                                                                                                   Int)
                                                                                                                                             :<|> ((NodeId
                                                                                                                                                    -> Maybe
                                                                                                                                                         NodeId
                                                                                                                                                    -> Handler
                                                                                                                                                         Int)
                                                                                                                                                   :<|> (Handler
                                                                                                                                                           [NodeId]
                                                                                                                                                         :<|> ((Maybe
                                                                                                                                                                  TabType
                                                                                                                                                                -> Maybe
                                                                                                                                                                     Int
                                                                                                                                                                -> Maybe
                                                                                                                                                                     Int
                                                                                                                                                                -> Maybe
                                                                                                                                                                     OrderBy
                                                                                                                                                                -> Handler
                                                                                                                                                                     [FacetDoc])
                                                                                                                                                               :<|> (((Maybe
                                                                                                                                                                         NodeId
                                                                                                                                                                       -> TabType
                                                                                                                                                                       -> Maybe
                                                                                                                                                                            Int
                                                                                                                                                                       -> Handler
                                                                                                                                                                            (HashedResponse
                                                                                                                                                                               Metrics))
                                                                                                                                                                      :<|> ((Maybe
                                                                                                                                                                               NodeId
                                                                                                                                                                             -> TabType
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  Int
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  ())
                                                                                                                                                                            :<|> (Maybe
                                                                                                                                                                                    NodeId
                                                                                                                                                                                  -> TabType
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       Text)))
                                                                                                                                                                     :<|> (((Maybe
                                                                                                                                                                               UTCTime
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  UTCTime
                                                                                                                                                                             -> Maybe
                                                                                                                                                                                  NodeId
                                                                                                                                                                             -> TabType
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  (HashedResponse
                                                                                                                                                                                     (ChartMetrics
                                                                                                                                                                                        Histo)))
                                                                                                                                                                            :<|> ((Maybe
                                                                                                                                                                                     NodeId
                                                                                                                                                                                   -> TabType
                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                        Int
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        ())
                                                                                                                                                                                  :<|> (Maybe
                                                                                                                                                                                          NodeId
                                                                                                                                                                                        -> TabType
                                                                                                                                                                                        -> Handler
                                                                                                                                                                                             Text)))
                                                                                                                                                                           :<|> (((Maybe
                                                                                                                                                                                     UTCTime
                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                        UTCTime
                                                                                                                                                                                   -> Maybe
                                                                                                                                                                                        NodeId
                                                                                                                                                                                   -> TabType
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        (HashedResponse
                                                                                                                                                                                           (ChartMetrics
                                                                                                                                                                                              Histo)))
                                                                                                                                                                                  :<|> ((Maybe
                                                                                                                                                                                           NodeId
                                                                                                                                                                                         -> TabType
                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                              Int
                                                                                                                                                                                         -> Handler
                                                                                                                                                                                              ())
                                                                                                                                                                                        :<|> (Maybe
                                                                                                                                                                                                NodeId
                                                                                                                                                                                              -> TabType
                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                   Text)))
                                                                                                                                                                                 :<|> (((Maybe
                                                                                                                                                                                           UTCTime
                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                              UTCTime
                                                                                                                                                                                         -> Maybe
                                                                                                                                                                                              NodeId
                                                                                                                                                                                         -> TabType
                                                                                                                                                                                         -> ListType
                                                                                                                                                                                         -> Handler
                                                                                                                                                                                              (HashedResponse
                                                                                                                                                                                                 (ChartMetrics
                                                                                                                                                                                                    (Vector
                                                                                                                                                                                                       NgramsTree))))
                                                                                                                                                                                        :<|> ((Maybe
                                                                                                                                                                                                 NodeId
                                                                                                                                                                                               -> TabType
                                                                                                                                                                                               -> ListType
                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                    ())
                                                                                                                                                                                              :<|> (Maybe
                                                                                                                                                                                                      NodeId
                                                                                                                                                                                                    -> TabType
                                                                                                                                                                                                    -> ListType
                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                         Text)))
                                                                                                                                                                                       :<|> (((Maybe
                                                                                                                                                                                                 NodeId
                                                                                                                                                                                               -> Maybe
                                                                                                                                                                                                    Int
                                                                                                                                                                                               -> Maybe
                                                                                                                                                                                                    Int
                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                    SVG)
                                                                                                                                                                                              :<|> (Maybe
                                                                                                                                                                                                      NodeId
                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                         NodeId))
                                                                                                                                                                                             :<|> ((NodeId
                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                         [Int])
                                                                                                                                                                                                   :<|> ((NodeId
                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                               Int)
                                                                                                                                                                                                         :<|> (Handler
                                                                                                                                                                                                                 (Headers
                                                                                                                                                                                                                    '[Header
                                                                                                                                                                                                                        "Content-Type"
                                                                                                                                                                                                                        Text]
                                                                                                                                                                                                                    BSResponse)
                                                                                                                                                                                                               :<|> ((Handler
                                                                                                                                                                                                                        (JobStatus
                                                                                                                                                                                                                           'Safe
                                                                                                                                                                                                                           JobLog)
                                                                                                                                                                                                                      :<|> ((JobInput
                                                                                                                                                                                                                               Maybe
                                                                                                                                                                                                                               NewWithFile
                                                                                                                                                                                                                             -> Handler
                                                                                                                                                                                                                                  (JobStatus
                                                                                                                                                                                                                                     'Safe
                                                                                                                                                                                                                                     JobLog))
                                                                                                                                                                                                                            :<|> (ID
                                                                                                                                                                                                                                    'Unsafe
                                                                                                                                                                                                                                    "job"
                                                                                                                                                                                                                                  -> (Maybe
                                                                                                                                                                                                                                        Limit
                                                                                                                                                                                                                                      -> Maybe
                                                                                                                                                                                                                                           Offset
                                                                                                                                                                                                                                      -> Handler
                                                                                                                                                                                                                                           (JobStatus
                                                                                                                                                                                                                                              'Safe
                                                                                                                                                                                                                                              JobLog))
                                                                                                                                                                                                                                     :<|> ((Maybe
                                                                                                                                                                                                                                              Limit
                                                                                                                                                                                                                                            -> Maybe
                                                                                                                                                                                                                                                 Offset
                                                                                                                                                                                                                                            -> Handler
                                                                                                                                                                                                                                                 (JobStatus
                                                                                                                                                                                                                                                    'Safe
                                                                                                                                                                                                                                                    JobLog))
                                                                                                                                                                                                                                           :<|> Handler