{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}

module Server (runServer, DocumentedAPI, PublicAPI, jwtSettings, cookieSettings, app, server) where

import Control.Lens
import Control.Monad.IO.Class
import Crypto.JOSE.JWK (JWK)
import Data.ByteString.Lazy (readFile)
import Data.Maybe (fromMaybe)
import Data.OpenApi
    ( OpenApi
    , description
    , info
    , license
    , servers
    , title
    , version
    )
import Data.Time (UTCTime)
import Data.UUID (toString)
import qualified Docs
import qualified Docs.Hasql.Database as DB
import GHC.Int (Int64)
import Network.Wai.Handler.Warp (run)
import Servant
import Servant.Auth.Server
import Servant.OpenApi (HasOpenApi (toOpenApi))
import Server.Auth (AuthMethod)
import qualified Server.Auth as Auth
import Server.DTOs.Logs (Logs (Logs))
import qualified Server.DTOs.Logs as Logs
import Server.Dump (DumpAPI, dumpHandler)
import Server.Handlers.AuthHandlers
import Server.Handlers.DocsHandlers (DocsAPI, docsServer, getUser, withDB)
import Server.Handlers.GroupHandlers
import Server.Handlers.PasswordResetHandlers
import Server.Handlers.RenderHandlers
import Server.Handlers.RoleHandlers
import Server.Handlers.UserHandlers
import Prelude hiding (readFile)

type PublicAPI =
    "ping" :> Get '[JSON] String
        :<|> "document" :> Get '[PDF] PDFByteString
        :<|> AuthAPI
        :<|> PasswordResetAPI
        :<|> DumpAPI

type ProtectedAPI =
    Auth AuthMethod Auth.Token
        :> "protected"
        :> Get '[JSON] String
        :<|> UserAPI
        :<|> GroupAPI
        :<|> RoleAPI
        :<|> DocsAPI
        :<|> RenderAPI
        :<|> LogsAPI

type SwaggerAPI = "swagger.json" :> Get '[JSON] OpenApi

type DocumentedAPI = SwaggerAPI :<|> PublicAPI :<|> ProtectedAPI

type LogsAPI =
    Auth AuthMethod Auth.Token
        :> "logs"
        :> QueryParam "before" UTCTime
        :> QueryParam "limit" Int64
        :> Get '[JSON] Logs

-- | The handler used for the developer logs endpoint
logsHandler
    :: AuthResult Auth.Token
    -> Maybe UTCTime
    -> Maybe Int64
    -> Handler Logs
logsHandler :: AuthResult Token -> Maybe UTCTime -> Maybe GroupID -> Handler Logs
logsHandler AuthResult Token
auth Maybe UTCTime
offset Maybe GroupID
limit = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    let limit' :: GroupID
limit' = GroupID -> Maybe GroupID -> GroupID
forall a. a -> Maybe a -> a
fromMaybe GroupID
20 Maybe GroupID
limit
    Vector LogMessage
messages <- (Connection
 -> IO (Either SessionError (Result (Vector LogMessage))))
-> Handler (Vector LogMessage)
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO (Either SessionError (Result (Vector LogMessage))))
 -> Handler (Vector LogMessage))
-> (Connection
    -> IO (Either SessionError (Result (Vector LogMessage))))
-> Handler (Vector LogMessage)
forall a b. (a -> b) -> a -> b
$ HasqlSession (Result (Vector LogMessage))
-> Connection
-> IO (Either SessionError (Result (Vector LogMessage)))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
DB.run (HasqlSession (Result (Vector LogMessage))
 -> Connection
 -> IO (Either SessionError (Result (Vector LogMessage))))
-> HasqlSession (Result (Vector LogMessage))
-> Connection
-> IO (Either SessionError (Result (Vector LogMessage)))
forall a b. (a -> b) -> a -> b
$ UserID
-> Maybe UTCTime
-> GroupID
-> HasqlSession (Result (Vector LogMessage))
forall (m :: * -> *).
(HasGetLogs m, HasLogMessage m) =>
UserID
-> Maybe UTCTime -> GroupID -> m (Result (Vector LogMessage))
Docs.getLogs UserID
userID Maybe UTCTime
offset GroupID
limit'
    Logs -> Handler Logs
forall a. a -> Handler a
forall (m :: * -> *) a. Monad m => a -> m a
return (Logs -> Handler Logs) -> Logs -> Handler Logs
forall a b. (a -> b) -> a -> b
$
        Logs
            { messages :: Vector LogMessage
Logs.messages = Vector LogMessage
messages
            , limit :: GroupID
Logs.limit = GroupID
limit'
            , offset :: Maybe UTCTime
Logs.offset = Maybe UTCTime
offset
            }

-- | A simple handler to test whether the API can be pinged
pingHandler :: Handler String
pingHandler :: Handler String
pingHandler = String -> Handler String
forall a. a -> Handler a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"pong"

-- | A handler to return a static PDF for testing
documentHandler :: Handler PDFByteString
documentHandler :: Handler PDFByteString
documentHandler = IO PDFByteString -> Handler PDFByteString
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PDFByteString -> Handler PDFByteString)
-> IO PDFByteString -> Handler PDFByteString
forall a b. (a -> b) -> a -> b
$ do
    ByteString
bs <- String -> IO ByteString
readFile String
"static/dummy.pdf"
    PDFByteString -> IO PDFByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (PDFByteString -> IO PDFByteString)
-> PDFByteString -> IO PDFByteString
forall a b. (a -> b) -> a -> b
$ ByteString -> PDFByteString
PDFByteString ByteString
bs

-- | A handler used to protect certain endpoints against being access unauthorized
protectedHandler :: AuthResult Auth.Token -> Handler String
protectedHandler :: AuthResult Token -> Handler String
protectedHandler (Authenticated Auth.Token {Bool
UserID
subject :: UserID
isSuperadmin :: Bool
isSuperadmin :: Token -> Bool
subject :: Token -> UserID
..}) =
    String -> Handler String
forall a. a -> Handler a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Handler String) -> String -> Handler String
forall a b. (a -> b) -> a -> b
$ String
"This is very private content of " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> UserID -> String
toString UserID
subject String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"!"
protectedHandler AuthResult Token
_ =
    ServerError -> Handler String
forall a. ServerError -> Handler a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError
        ServerError
err403
            { errBody = "Not allowed! You need to login to see this content.\n"
            }

api :: Proxy (PublicAPI :<|> ProtectedAPI)
api :: Proxy (PublicAPI :<|> ProtectedAPI)
api = Proxy (PublicAPI :<|> ProtectedAPI)
forall {k} (t :: k). Proxy t
Proxy

swagger :: OpenApi
swagger :: OpenApi
swagger =
    Proxy (PublicAPI :<|> ProtectedAPI) -> OpenApi
forall {k} (api :: k). HasOpenApi api => Proxy api -> OpenApi
toOpenApi Proxy (PublicAPI :<|> ProtectedAPI)
api
        OpenApi -> (OpenApi -> OpenApi) -> OpenApi
forall a b. a -> (a -> b) -> b
& (Info -> Identity Info) -> OpenApi -> Identity OpenApi
forall s a. HasInfo s a => Lens' s a
Lens' OpenApi Info
info ((Info -> Identity Info) -> OpenApi -> Identity OpenApi)
-> ((Text -> Identity Text) -> Info -> Identity Info)
-> (Text -> Identity Text)
-> OpenApi
-> Identity OpenApi
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Identity Text) -> Info -> Identity Info
forall s a. HasTitle s a => Lens' s a
Lens' Info Text
title ((Text -> Identity Text) -> OpenApi -> Identity OpenApi)
-> Text -> OpenApi -> OpenApi
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Text
"Fachprüfungsordnung API"
        OpenApi -> (OpenApi -> OpenApi) -> OpenApi
forall a b. a -> (a -> b) -> b
& (Info -> Identity Info) -> OpenApi -> Identity OpenApi
forall s a. HasInfo s a => Lens' s a
Lens' OpenApi Info
info ((Info -> Identity Info) -> OpenApi -> Identity OpenApi)
-> ((Text -> Identity Text) -> Info -> Identity Info)
-> (Text -> Identity Text)
-> OpenApi
-> Identity OpenApi
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Identity Text) -> Info -> Identity Info
forall s a. HasVersion s a => Lens' s a
Lens' Info Text
version ((Text -> Identity Text) -> OpenApi -> Identity OpenApi)
-> Text -> OpenApi -> OpenApi
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Text
"1.0"
        OpenApi -> (OpenApi -> OpenApi) -> OpenApi
forall a b. a -> (a -> b) -> b
& (Info -> Identity Info) -> OpenApi -> Identity OpenApi
forall s a. HasInfo s a => Lens' s a
Lens' OpenApi Info
info ((Info -> Identity Info) -> OpenApi -> Identity OpenApi)
-> ((Maybe Text -> Identity (Maybe Text)) -> Info -> Identity Info)
-> (Maybe Text -> Identity (Maybe Text))
-> OpenApi
-> Identity OpenApi
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Text -> Identity (Maybe Text)) -> Info -> Identity Info
forall s a. HasDescription s a => Lens' s a
Lens' Info (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> OpenApi -> Identity OpenApi)
-> Text -> OpenApi -> OpenApi
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"This is the API for the Fachprüfungsordnung editor."
        OpenApi -> (OpenApi -> OpenApi) -> OpenApi
forall a b. a -> (a -> b) -> b
& (Info -> Identity Info) -> OpenApi -> Identity OpenApi
forall s a. HasInfo s a => Lens' s a
Lens' OpenApi Info
info ((Info -> Identity Info) -> OpenApi -> Identity OpenApi)
-> ((Maybe License -> Identity (Maybe License))
    -> Info -> Identity Info)
-> (Maybe License -> Identity (Maybe License))
-> OpenApi
-> Identity OpenApi
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe License -> Identity (Maybe License))
-> Info -> Identity Info
forall s a. HasLicense s a => Lens' s a
Lens' Info (Maybe License)
license ((Maybe License -> Identity (Maybe License))
 -> OpenApi -> Identity OpenApi)
-> License -> OpenApi -> OpenApi
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ License
"AGPL3"
        OpenApi -> (OpenApi -> OpenApi) -> OpenApi
forall a b. a -> (a -> b) -> b
& ([Server] -> Identity [Server]) -> OpenApi -> Identity OpenApi
forall s a. HasServers s a => Lens' s a
Lens' OpenApi [Server]
servers
            (([Server] -> Identity [Server]) -> OpenApi -> Identity OpenApi)
-> [Server] -> OpenApi -> OpenApi
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [ Server
"https://batailley.informatik.uni-kiel.de/api/"
               , Server
"https://fpo-dev.bahn.sh/api/"
               , Server
"http://localhost:8080/api/"
               ]

server :: CookieSettings -> JWTSettings -> Server DocumentedAPI
server :: CookieSettings -> JWTSettings -> Server DocumentedAPI
server CookieSettings
cookieSett JWTSettings
jwtSett =
    OpenApi -> Handler OpenApi
forall a. a -> Handler a
forall (m :: * -> *) a. Monad m => a -> m a
return OpenApi
swagger
        Handler OpenApi
-> ((Handler String
     :<|> (Handler PDFByteString
           :<|> (((UserLoginData
                   -> Handler
                        (Headers
                           '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                           NoContent))
                  :<|> Handler
                         (Headers
                            '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                            NoContent))
                 :<|> (((PasswordResetRequest -> Handler NoContent)
                        :<|> (PasswordResetConfirm -> Handler NoContent))
                       :<|> Handler SQLBytes))))
    :<|> ((AuthResult Token -> Handler String)
          :<|> (((AuthResult Token -> UserRegisterData -> Handler UserID)
                 :<|> (((AuthResult Token -> Handler FullUser)
                        :<|> (AuthResult Token -> Text -> Handler NoContent))
                       :<|> ((AuthResult Token -> Handler [User])
                             :<|> ((AuthResult Token -> UserID -> Handler FullUser)
                                   :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                         :<|> (AuthResult Token
                                               -> UserID -> UserUpdate -> Handler NoContent))))))
                :<|> (((AuthResult Token -> GroupCreate -> Handler GroupID)
                       :<|> ((AuthResult Token -> Handler [GroupOverview])
                             :<|> ((AuthResult Token -> GroupID -> Handler Group)
                                   :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                                         :<|> (AuthResult Token
                                               -> GroupID
                                               -> GroupPatch
                                               -> Handler GroupOverview)))))
                      :<|> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
                             :<|> ((AuthResult Token
                                    -> GroupID -> UserID -> Role -> Handler NoContent)
                                   :<|> ((AuthResult Token
                                          -> GroupID -> UserID -> Handler NoContent)
                                         :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                               :<|> (AuthResult Token
                                                     -> UserID -> Handler NoContent)))))
                            :<|> (((AuthResult Token
                                    -> CreateDocument
                                    -> Handler (FullDocument (Rendered TextElementRevision)))
                                   :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                                         :<|> ((AuthResult Token
                                                -> Maybe UserID
                                                -> Maybe GroupID
                                                -> Handler Documents)
                                               :<|> ((AuthResult Token
                                                      -> DocumentID
                                                      -> CreateTextElement
                                                      -> Handler TextElement)
                                                     :<|> ((AuthResult Token
                                                            -> DocumentID
                                                            -> TextElementID
                                                            -> Maybe Bool
                                                            -> CreateTextRevision
                                                            -> Handler (Rendered ConflictStatus))
                                                           :<|> ((AuthResult Token
                                                                  -> DocumentID
                                                                  -> TextElementID
                                                                  -> TextRevisionSelector
                                                                  -> Handler
                                                                       (Maybe
                                                                          (Rendered
                                                                             TextElementRevision)))
                                                                 :<|> ((AuthResult Token
                                                                        -> DocumentID
                                                                        -> TextElementID
                                                                        -> TextRevisionSelector
                                                                        -> Handler PDFBytes)
                                                                       :<|> ((AuthResult Token
                                                                              -> DocumentID
                                                                              -> Node TextElementID
                                                                              -> Handler
                                                                                   (TreeRevisionWithMetaData
                                                                                      TextElementID))
                                                                             :<|> ((AuthResult Token
                                                                                    -> DocumentID
                                                                                    -> TreeRevisionSelector
                                                                                    -> Handler
                                                                                         (Maybe
                                                                                            (TreeRevisionWithMetaData
                                                                                               TextElement)))
                                                                                   :<|> ((AuthResult
                                                                                            Token
                                                                                          -> DocumentID
                                                                                          -> TreeRevisionSelector
                                                                                          -> Handler
                                                                                               (Maybe
                                                                                                  (TreeRevisionWithMetaData
                                                                                                     TextElementRevision)))
                                                                                         :<|> ((AuthResult
                                                                                                  Token
                                                                                                -> DocumentID
                                                                                                -> TreeRevisionSelector
                                                                                                -> Handler
                                                                                                     PDFBytes)
                                                                                               :<|> ((AuthResult
                                                                                                        Token
                                                                                                      -> DocumentID
                                                                                                      -> TreeRevisionSelector
                                                                                                      -> Handler
                                                                                                           ZipBytes)
                                                                                                     :<|> ((AuthResult
                                                                                                              Token
                                                                                                            -> DocumentID
                                                                                                            -> TextElementID
                                                                                                            -> Maybe
                                                                                                                 UTCTime
                                                                                                            -> Maybe
                                                                                                                 UTCTime
                                                                                                            -> Maybe
                                                                                                                 GroupID
                                                                                                            -> Handler
                                                                                                                 TextRevisionHistory)
                                                                                                           :<|> ((AuthResult
                                                                                                                    Token
                                                                                                                  -> DocumentID
                                                                                                                  -> Maybe
                                                                                                                       UTCTime
                                                                                                                  -> Maybe
                                                                                                                       GroupID
                                                                                                                  -> Handler
                                                                                                                       TreeRevisionHistory)
                                                                                                                 :<|> ((AuthResult
                                                                                                                          Token
                                                                                                                        -> DocumentID
                                                                                                                        -> Maybe
                                                                                                                             UTCTime
                                                                                                                        -> Maybe
                                                                                                                             GroupID
                                                                                                                        -> Handler
                                                                                                                             DocumentHistory)
                                                                                                                       :<|> ((AuthResult
                                                                                                                                Token
                                                                                                                              -> DocumentID
                                                                                                                              -> TextElementID
                                                                                                                              -> CreateComment
                                                                                                                              -> Handler
                                                                                                                                   Comment)
                                                                                                                             :<|> ((AuthResult
                                                                                                                                      Token
                                                                                                                                    -> DocumentID
                                                                                                                                    -> TextElementID
                                                                                                                                    -> Handler
                                                                                                                                         Comments)
                                                                                                                                   :<|> ((AuthResult
                                                                                                                                            Token
                                                                                                                                          -> DocumentID
                                                                                                                                          -> TextElementID
                                                                                                                                          -> CommentID
                                                                                                                                          -> Handler
                                                                                                                                               ())
                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                  Token
                                                                                                                                                -> DocumentID
                                                                                                                                                -> TextElementID
                                                                                                                                                -> CommentID
                                                                                                                                                -> CreateReply
                                                                                                                                                -> Handler
                                                                                                                                                     Message)
                                                                                                                                               :<|> ((AuthResult
                                                                                                                                                        Token
                                                                                                                                                      -> DocumentID
                                                                                                                                                      -> RevisionSelector
                                                                                                                                                      -> Handler
                                                                                                                                                           (FullDocument
                                                                                                                                                              TextElementRevision))
                                                                                                                                                     :<|> ((AuthResult
                                                                                                                                                              Token
                                                                                                                                                            -> DocumentID
                                                                                                                                                            -> RevisionSelector
                                                                                                                                                            -> Handler
                                                                                                                                                                 PDFBytes)
                                                                                                                                                           :<|> ((AuthResult
                                                                                                                                                                    Token
                                                                                                                                                                  -> DocumentID
                                                                                                                                                                  -> RevisionSelector
                                                                                                                                                                  -> Handler
                                                                                                                                                                       ZipBytes)
                                                                                                                                                                 :<|> ((AuthResult
                                                                                                                                                                          Token
                                                                                                                                                                        -> DocumentID
                                                                                                                                                                        -> RevisionSelector
                                                                                                                                                                        -> Handler
                                                                                                                                                                             (Maybe
                                                                                                                                                                                (TreeRevision
                                                                                                                                                                                   TextElement)))
                                                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                                                Token
                                                                                                                                                                              -> DocumentID
                                                                                                                                                                              -> RevisionSelector
                                                                                                                                                                              -> TextElementID
                                                                                                                                                                              -> Handler
                                                                                                                                                                                   (Maybe
                                                                                                                                                                                      TextElementRevision))
                                                                                                                                                                             :<|> ((AuthResult
                                                                                                                                                                                      Token
                                                                                                                                                                                    -> DocumentID
                                                                                                                                                                                    -> TextElementID
                                                                                                                                                                                    -> Handler
                                                                                                                                                                                         (Maybe
                                                                                                                                                                                            (Rendered
                                                                                                                                                                                               DraftRevision)))
                                                                                                                                                                                   :<|> ((AuthResult
                                                                                                                                                                                            Token
                                                                                                                                                                                          -> DocumentID
                                                                                                                                                                                          -> TextElementID
                                                                                                                                                                                          -> Handler
                                                                                                                                                                                               (Rendered
                                                                                                                                                                                                  ConflictStatus))
                                                                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                                                                  Token
                                                                                                                                                                                                -> DocumentID
                                                                                                                                                                                                -> TextElementID
                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                     ())
                                                                                                                                                                                               :<|> ((AuthResult
                                                                                                                                                                                                        Token
                                                                                                                                                                                                      -> Text
                                                                                                                                                                                                      -> Handler
                                                                                                                                                                                                           DocByteString)
                                                                                                                                                                                                     :<|> (AuthResult
                                                                                                                                                                                                             Token
                                                                                                                                                                                                           -> Text
                                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                                PDFByteString)))))))))))))))))))))))))))))
                                  :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                                         :<|> (AuthResult Token -> Text -> Handler PDFByteString))
                                        :<|> (AuthResult Token
                                              -> Maybe UTCTime
                                              -> Maybe GroupID
                                              -> Handler Logs))))))))
-> Handler OpenApi
   :<|> ((Handler String
          :<|> (Handler PDFByteString
                :<|> (((UserLoginData
                        -> Handler
                             (Headers
                                '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                                NoContent))
                       :<|> Handler
                              (Headers
                                 '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                                 NoContent))
                      :<|> (((PasswordResetRequest -> Handler NoContent)
                             :<|> (PasswordResetConfirm -> Handler NoContent))
                            :<|> Handler SQLBytes))))
         :<|> ((AuthResult Token -> Handler String)
               :<|> (((AuthResult Token -> UserRegisterData -> Handler UserID)
                      :<|> (((AuthResult Token -> Handler FullUser)
                             :<|> (AuthResult Token -> Text -> Handler NoContent))
                            :<|> ((AuthResult Token -> Handler [User])
                                  :<|> ((AuthResult Token -> UserID -> Handler FullUser)
                                        :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                              :<|> (AuthResult Token
                                                    -> UserID
                                                    -> UserUpdate
                                                    -> Handler NoContent))))))
                     :<|> (((AuthResult Token -> GroupCreate -> Handler GroupID)
                            :<|> ((AuthResult Token -> Handler [GroupOverview])
                                  :<|> ((AuthResult Token -> GroupID -> Handler Group)
                                        :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                                              :<|> (AuthResult Token
                                                    -> GroupID
                                                    -> GroupPatch
                                                    -> Handler GroupOverview)))))
                           :<|> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
                                  :<|> ((AuthResult Token
                                         -> GroupID -> UserID -> Role -> Handler NoContent)
                                        :<|> ((AuthResult Token
                                               -> GroupID -> UserID -> Handler NoContent)
                                              :<|> ((AuthResult Token
                                                     -> UserID -> Handler NoContent)
                                                    :<|> (AuthResult Token
                                                          -> UserID -> Handler NoContent)))))
                                 :<|> (((AuthResult Token
                                         -> CreateDocument
                                         -> Handler (FullDocument (Rendered TextElementRevision)))
                                        :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                                              :<|> ((AuthResult Token
                                                     -> Maybe UserID
                                                     -> Maybe GroupID
                                                     -> Handler Documents)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> CreateTextElement
                                                           -> Handler TextElement)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> Maybe Bool
                                                                 -> CreateTextRevision
                                                                 -> Handler
                                                                      (Rendered ConflictStatus))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> TextRevisionSelector
                                                                       -> Handler
                                                                            (Maybe
                                                                               (Rendered
                                                                                  TextElementRevision)))
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TextElementID
                                                                             -> TextRevisionSelector
                                                                             -> Handler PDFBytes)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> Node
                                                                                        TextElementID
                                                                                   -> Handler
                                                                                        (TreeRevisionWithMetaData
                                                                                           TextElementID))
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TreeRevisionSelector
                                                                                         -> Handler
                                                                                              (Maybe
                                                                                                 (TreeRevisionWithMetaData
                                                                                                    TextElement)))
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TreeRevisionSelector
                                                                                               -> Handler
                                                                                                    (Maybe
                                                                                                       (TreeRevisionWithMetaData
                                                                                                          TextElementRevision)))
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TreeRevisionSelector
                                                                                                     -> Handler
                                                                                                          PDFBytes)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> TreeRevisionSelector
                                                                                                           -> Handler
                                                                                                                ZipBytes)
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> TextElementID
                                                                                                                 -> Maybe
                                                                                                                      UTCTime
                                                                                                                 -> Maybe
                                                                                                                      UTCTime
                                                                                                                 -> Maybe
                                                                                                                      GroupID
                                                                                                                 -> Handler
                                                                                                                      TextRevisionHistory)
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> Maybe
                                                                                                                            UTCTime
                                                                                                                       -> Maybe
                                                                                                                            GroupID
                                                                                                                       -> Handler
                                                                                                                            TreeRevisionHistory)
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> Maybe
                                                                                                                                  UTCTime
                                                                                                                             -> Maybe
                                                                                                                                  GroupID
                                                                                                                             -> Handler
                                                                                                                                  DocumentHistory)
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> TextElementID
                                                                                                                                   -> CreateComment
                                                                                                                                   -> Handler
                                                                                                                                        Comment)
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> TextElementID
                                                                                                                                         -> Handler
                                                                                                                                              Comments)
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> TextElementID
                                                                                                                                               -> CommentID
                                                                                                                                               -> Handler
                                                                                                                                                    ())
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> DocumentID
                                                                                                                                                     -> TextElementID
                                                                                                                                                     -> CommentID
                                                                                                                                                     -> CreateReply
                                                                                                                                                     -> Handler
                                                                                                                                                          Message)
                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                             Token
                                                                                                                                                           -> DocumentID
                                                                                                                                                           -> RevisionSelector
                                                                                                                                                           -> Handler
                                                                                                                                                                (FullDocument
                                                                                                                                                                   TextElementRevision))
                                                                                                                                                          :<|> ((AuthResult
                                                                                                                                                                   Token
                                                                                                                                                                 -> DocumentID
                                                                                                                                                                 -> RevisionSelector
                                                                                                                                                                 -> Handler
                                                                                                                                                                      PDFBytes)
                                                                                                                                                                :<|> ((AuthResult
                                                                                                                                                                         Token
                                                                                                                                                                       -> DocumentID
                                                                                                                                                                       -> RevisionSelector
                                                                                                                                                                       -> Handler
                                                                                                                                                                            ZipBytes)
                                                                                                                                                                      :<|> ((AuthResult
                                                                                                                                                                               Token
                                                                                                                                                                             -> DocumentID
                                                                                                                                                                             -> RevisionSelector
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  (Maybe
                                                                                                                                                                                     (TreeRevision
                                                                                                                                                                                        TextElement)))
                                                                                                                                                                            :<|> ((AuthResult
                                                                                                                                                                                     Token
                                                                                                                                                                                   -> DocumentID
                                                                                                                                                                                   -> RevisionSelector
                                                                                                                                                                                   -> TextElementID
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        (Maybe
                                                                                                                                                                                           TextElementRevision))
                                                                                                                                                                                  :<|> ((AuthResult
                                                                                                                                                                                           Token
                                                                                                                                                                                         -> DocumentID
                                                                                                                                                                                         -> TextElementID
                                                                                                                                                                                         -> Handler
                                                                                                                                                                                              (Maybe
                                                                                                                                                                                                 (Rendered
                                                                                                                                                                                                    DraftRevision)))
                                                                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                                                                 Token
                                                                                                                                                                                               -> DocumentID
                                                                                                                                                                                               -> TextElementID
                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                    (Rendered
                                                                                                                                                                                                       ConflictStatus))
                                                                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                                                                       Token
                                                                                                                                                                                                     -> DocumentID
                                                                                                                                                                                                     -> TextElementID
                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                          ())
                                                                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                                                                             Token
                                                                                                                                                                                                           -> Text
                                                                                                                                                                                                           -> Handler
                                                                                                                                                                                                                DocByteString)
                                                                                                                                                                                                          :<|> (AuthResult
                                                                                                                                                                                                                  Token
                                                                                                                                                                                                                -> Text
                                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                                     PDFByteString)))))))))))))))))))))))))))))
                                       :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                                              :<|> (AuthResult Token
                                                    -> Text -> Handler PDFByteString))
                                             :<|> (AuthResult Token
                                                   -> Maybe UTCTime
                                                   -> Maybe GroupID
                                                   -> Handler Logs))))))))
forall a b. a -> b -> a :<|> b
:<|> ( Handler String
pingHandler
                Handler String
-> (Handler PDFByteString
    :<|> (((UserLoginData
            -> Handler
                 (Headers
                    '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                    NoContent))
           :<|> Handler
                  (Headers
                     '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                     NoContent))
          :<|> (((PasswordResetRequest -> Handler NoContent)
                 :<|> (PasswordResetConfirm -> Handler NoContent))
                :<|> Handler SQLBytes)))
-> Handler String
   :<|> (Handler PDFByteString
         :<|> (((UserLoginData
                 -> Handler
                      (Headers
                         '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                         NoContent))
                :<|> Handler
                       (Headers
                          '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                          NoContent))
               :<|> (((PasswordResetRequest -> Handler NoContent)
                      :<|> (PasswordResetConfirm -> Handler NoContent))
                     :<|> Handler SQLBytes)))
forall a b. a -> b -> a :<|> b
:<|> Handler PDFByteString
documentHandler
                Handler PDFByteString
-> (((UserLoginData
      -> Handler
           (Headers
              '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
              NoContent))
     :<|> Handler
            (Headers
               '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
               NoContent))
    :<|> (((PasswordResetRequest -> Handler NoContent)
           :<|> (PasswordResetConfirm -> Handler NoContent))
          :<|> Handler SQLBytes))
-> Handler PDFByteString
   :<|> (((UserLoginData
           -> Handler
                (Headers
                   '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                   NoContent))
          :<|> Handler
                 (Headers
                    '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                    NoContent))
         :<|> (((PasswordResetRequest -> Handler NoContent)
                :<|> (PasswordResetConfirm -> Handler NoContent))
               :<|> Handler SQLBytes))
forall a b. a -> b -> a :<|> b
:<|> CookieSettings -> JWTSettings -> Server AuthAPI
authServer CookieSettings
cookieSett JWTSettings
jwtSett
                ((UserLoginData
  -> Handler
       (Headers
          '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
          NoContent))
 :<|> Handler
        (Headers
           '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
           NoContent))
-> (((PasswordResetRequest -> Handler NoContent)
     :<|> (PasswordResetConfirm -> Handler NoContent))
    :<|> Handler SQLBytes)
-> ((UserLoginData
     -> Handler
          (Headers
             '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
             NoContent))
    :<|> Handler
           (Headers
              '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
              NoContent))
   :<|> (((PasswordResetRequest -> Handler NoContent)
          :<|> (PasswordResetConfirm -> Handler NoContent))
         :<|> Handler SQLBytes)
forall a b. a -> b -> a :<|> b
:<|> (PasswordResetRequest -> Handler NoContent)
:<|> (PasswordResetConfirm -> Handler NoContent)
Server PasswordResetAPI
passwordResetServer
                ((PasswordResetRequest -> Handler NoContent)
 :<|> (PasswordResetConfirm -> Handler NoContent))
-> Handler SQLBytes
-> ((PasswordResetRequest -> Handler NoContent)
    :<|> (PasswordResetConfirm -> Handler NoContent))
   :<|> Handler SQLBytes
forall a b. a -> b -> a :<|> b
:<|> Handler SQLBytes
dumpHandler
             )
        (Handler String
 :<|> (Handler PDFByteString
       :<|> (((UserLoginData
               -> Handler
                    (Headers
                       '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                       NoContent))
              :<|> Handler
                     (Headers
                        '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                        NoContent))
             :<|> (((PasswordResetRequest -> Handler NoContent)
                    :<|> (PasswordResetConfirm -> Handler NoContent))
                   :<|> Handler SQLBytes))))
-> ((AuthResult Token -> Handler String)
    :<|> (((AuthResult Token -> UserRegisterData -> Handler UserID)
           :<|> (((AuthResult Token -> Handler FullUser)
                  :<|> (AuthResult Token -> Text -> Handler NoContent))
                 :<|> ((AuthResult Token -> Handler [User])
                       :<|> ((AuthResult Token -> UserID -> Handler FullUser)
                             :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                   :<|> (AuthResult Token
                                         -> UserID -> UserUpdate -> Handler NoContent))))))
          :<|> (((AuthResult Token -> GroupCreate -> Handler GroupID)
                 :<|> ((AuthResult Token -> Handler [GroupOverview])
                       :<|> ((AuthResult Token -> GroupID -> Handler Group)
                             :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                                   :<|> (AuthResult Token
                                         -> GroupID -> GroupPatch -> Handler GroupOverview)))))
                :<|> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
                       :<|> ((AuthResult Token
                              -> GroupID -> UserID -> Role -> Handler NoContent)
                             :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
                                   :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                         :<|> (AuthResult Token -> UserID -> Handler NoContent)))))
                      :<|> (((AuthResult Token
                              -> CreateDocument
                              -> Handler (FullDocument (Rendered TextElementRevision)))
                             :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                                   :<|> ((AuthResult Token
                                          -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                                         :<|> ((AuthResult Token
                                                -> DocumentID
                                                -> CreateTextElement
                                                -> Handler TextElement)
                                               :<|> ((AuthResult Token
                                                      -> DocumentID
                                                      -> TextElementID
                                                      -> Maybe Bool
                                                      -> CreateTextRevision
                                                      -> Handler (Rendered ConflictStatus))
                                                     :<|> ((AuthResult Token
                                                            -> DocumentID
                                                            -> TextElementID
                                                            -> TextRevisionSelector
                                                            -> Handler
                                                                 (Maybe
                                                                    (Rendered TextElementRevision)))
                                                           :<|> ((AuthResult Token
                                                                  -> DocumentID
                                                                  -> TextElementID
                                                                  -> TextRevisionSelector
                                                                  -> Handler PDFBytes)
                                                                 :<|> ((AuthResult Token
                                                                        -> DocumentID
                                                                        -> Node TextElementID
                                                                        -> Handler
                                                                             (TreeRevisionWithMetaData
                                                                                TextElementID))
                                                                       :<|> ((AuthResult Token
                                                                              -> DocumentID
                                                                              -> TreeRevisionSelector
                                                                              -> Handler
                                                                                   (Maybe
                                                                                      (TreeRevisionWithMetaData
                                                                                         TextElement)))
                                                                             :<|> ((AuthResult Token
                                                                                    -> DocumentID
                                                                                    -> TreeRevisionSelector
                                                                                    -> Handler
                                                                                         (Maybe
                                                                                            (TreeRevisionWithMetaData
                                                                                               TextElementRevision)))
                                                                                   :<|> ((AuthResult
                                                                                            Token
                                                                                          -> DocumentID
                                                                                          -> TreeRevisionSelector
                                                                                          -> Handler
                                                                                               PDFBytes)
                                                                                         :<|> ((AuthResult
                                                                                                  Token
                                                                                                -> DocumentID
                                                                                                -> TreeRevisionSelector
                                                                                                -> Handler
                                                                                                     ZipBytes)
                                                                                               :<|> ((AuthResult
                                                                                                        Token
                                                                                                      -> DocumentID
                                                                                                      -> TextElementID
                                                                                                      -> Maybe
                                                                                                           UTCTime
                                                                                                      -> Maybe
                                                                                                           UTCTime
                                                                                                      -> Maybe
                                                                                                           GroupID
                                                                                                      -> Handler
                                                                                                           TextRevisionHistory)
                                                                                                     :<|> ((AuthResult
                                                                                                              Token
                                                                                                            -> DocumentID
                                                                                                            -> Maybe
                                                                                                                 UTCTime
                                                                                                            -> Maybe
                                                                                                                 GroupID
                                                                                                            -> Handler
                                                                                                                 TreeRevisionHistory)
                                                                                                           :<|> ((AuthResult
                                                                                                                    Token
                                                                                                                  -> DocumentID
                                                                                                                  -> Maybe
                                                                                                                       UTCTime
                                                                                                                  -> Maybe
                                                                                                                       GroupID
                                                                                                                  -> Handler
                                                                                                                       DocumentHistory)
                                                                                                                 :<|> ((AuthResult
                                                                                                                          Token
                                                                                                                        -> DocumentID
                                                                                                                        -> TextElementID
                                                                                                                        -> CreateComment
                                                                                                                        -> Handler
                                                                                                                             Comment)
                                                                                                                       :<|> ((AuthResult
                                                                                                                                Token
                                                                                                                              -> DocumentID
                                                                                                                              -> TextElementID
                                                                                                                              -> Handler
                                                                                                                                   Comments)
                                                                                                                             :<|> ((AuthResult
                                                                                                                                      Token
                                                                                                                                    -> DocumentID
                                                                                                                                    -> TextElementID
                                                                                                                                    -> CommentID
                                                                                                                                    -> Handler
                                                                                                                                         ())
                                                                                                                                   :<|> ((AuthResult
                                                                                                                                            Token
                                                                                                                                          -> DocumentID
                                                                                                                                          -> TextElementID
                                                                                                                                          -> CommentID
                                                                                                                                          -> CreateReply
                                                                                                                                          -> Handler
                                                                                                                                               Message)
                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                  Token
                                                                                                                                                -> DocumentID
                                                                                                                                                -> RevisionSelector
                                                                                                                                                -> Handler
                                                                                                                                                     (FullDocument
                                                                                                                                                        TextElementRevision))
                                                                                                                                               :<|> ((AuthResult
                                                                                                                                                        Token
                                                                                                                                                      -> DocumentID
                                                                                                                                                      -> RevisionSelector
                                                                                                                                                      -> Handler
                                                                                                                                                           PDFBytes)
                                                                                                                                                     :<|> ((AuthResult
                                                                                                                                                              Token
                                                                                                                                                            -> DocumentID
                                                                                                                                                            -> RevisionSelector
                                                                                                                                                            -> Handler
                                                                                                                                                                 ZipBytes)
                                                                                                                                                           :<|> ((AuthResult
                                                                                                                                                                    Token
                                                                                                                                                                  -> DocumentID
                                                                                                                                                                  -> RevisionSelector
                                                                                                                                                                  -> Handler
                                                                                                                                                                       (Maybe
                                                                                                                                                                          (TreeRevision
                                                                                                                                                                             TextElement)))
                                                                                                                                                                 :<|> ((AuthResult
                                                                                                                                                                          Token
                                                                                                                                                                        -> DocumentID
                                                                                                                                                                        -> RevisionSelector
                                                                                                                                                                        -> TextElementID
                                                                                                                                                                        -> Handler
                                                                                                                                                                             (Maybe
                                                                                                                                                                                TextElementRevision))
                                                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                                                Token
                                                                                                                                                                              -> DocumentID
                                                                                                                                                                              -> TextElementID
                                                                                                                                                                              -> Handler
                                                                                                                                                                                   (Maybe
                                                                                                                                                                                      (Rendered
                                                                                                                                                                                         DraftRevision)))
                                                                                                                                                                             :<|> ((AuthResult
                                                                                                                                                                                      Token
                                                                                                                                                                                    -> DocumentID
                                                                                                                                                                                    -> TextElementID
                                                                                                                                                                                    -> Handler
                                                                                                                                                                                         (Rendered
                                                                                                                                                                                            ConflictStatus))
                                                                                                                                                                                   :<|> ((AuthResult
                                                                                                                                                                                            Token
                                                                                                                                                                                          -> DocumentID
                                                                                                                                                                                          -> TextElementID
                                                                                                                                                                                          -> Handler
                                                                                                                                                                                               ())
                                                                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                                                                  Token
                                                                                                                                                                                                -> Text
                                                                                                                                                                                                -> Handler
                                                                                                                                                                                                     DocByteString)
                                                                                                                                                                                               :<|> (AuthResult
                                                                                                                                                                                                       Token
                                                                                                                                                                                                     -> Text
                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                          PDFByteString)))))))))))))))))))))))))))))
                            :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                                   :<|> (AuthResult Token -> Text -> Handler PDFByteString))
                                  :<|> (AuthResult Token
                                        -> Maybe UTCTime -> Maybe GroupID -> Handler Logs)))))))
-> (Handler String
    :<|> (Handler PDFByteString
          :<|> (((UserLoginData
                  -> Handler
                       (Headers
                          '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                          NoContent))
                 :<|> Handler
                        (Headers
                           '[Header "Set-Cookie" SetCookie, Header "Set-Cookie" SetCookie]
                           NoContent))
                :<|> (((PasswordResetRequest -> Handler NoContent)
                       :<|> (PasswordResetConfirm -> Handler NoContent))
                      :<|> Handler SQLBytes))))
   :<|> ((AuthResult Token -> Handler String)
         :<|> (((AuthResult Token -> UserRegisterData -> Handler UserID)
                :<|> (((AuthResult Token -> Handler FullUser)
                       :<|> (AuthResult Token -> Text -> Handler NoContent))
                      :<|> ((AuthResult Token -> Handler [User])
                            :<|> ((AuthResult Token -> UserID -> Handler FullUser)
                                  :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                        :<|> (AuthResult Token
                                              -> UserID -> UserUpdate -> Handler NoContent))))))
               :<|> (((AuthResult Token -> GroupCreate -> Handler GroupID)
                      :<|> ((AuthResult Token -> Handler [GroupOverview])
                            :<|> ((AuthResult Token -> GroupID -> Handler Group)
                                  :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                                        :<|> (AuthResult Token
                                              -> GroupID -> GroupPatch -> Handler GroupOverview)))))
                     :<|> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
                            :<|> ((AuthResult Token
                                   -> GroupID -> UserID -> Role -> Handler NoContent)
                                  :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
                                        :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                              :<|> (AuthResult Token
                                                    -> UserID -> Handler NoContent)))))
                           :<|> (((AuthResult Token
                                   -> CreateDocument
                                   -> Handler (FullDocument (Rendered TextElementRevision)))
                                  :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                                        :<|> ((AuthResult Token
                                               -> Maybe UserID
                                               -> Maybe GroupID
                                               -> Handler Documents)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> CreateTextElement
                                                     -> Handler TextElement)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> Maybe Bool
                                                           -> CreateTextRevision
                                                           -> Handler (Rendered ConflictStatus))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> TextRevisionSelector
                                                                 -> Handler
                                                                      (Maybe
                                                                         (Rendered
                                                                            TextElementRevision)))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> TextRevisionSelector
                                                                       -> Handler PDFBytes)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> Node TextElementID
                                                                             -> Handler
                                                                                  (TreeRevisionWithMetaData
                                                                                     TextElementID))
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TreeRevisionSelector
                                                                                   -> Handler
                                                                                        (Maybe
                                                                                           (TreeRevisionWithMetaData
                                                                                              TextElement)))
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TreeRevisionSelector
                                                                                         -> Handler
                                                                                              (Maybe
                                                                                                 (TreeRevisionWithMetaData
                                                                                                    TextElementRevision)))
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TreeRevisionSelector
                                                                                               -> Handler
                                                                                                    PDFBytes)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TreeRevisionSelector
                                                                                                     -> Handler
                                                                                                          ZipBytes)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> TextElementID
                                                                                                           -> Maybe
                                                                                                                UTCTime
                                                                                                           -> Maybe
                                                                                                                UTCTime
                                                                                                           -> Maybe
                                                                                                                GroupID
                                                                                                           -> Handler
                                                                                                                TextRevisionHistory)
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> Maybe
                                                                                                                      UTCTime
                                                                                                                 -> Maybe
                                                                                                                      GroupID
                                                                                                                 -> Handler
                                                                                                                      TreeRevisionHistory)
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> Maybe
                                                                                                                            UTCTime
                                                                                                                       -> Maybe
                                                                                                                            GroupID
                                                                                                                       -> Handler
                                                                                                                            DocumentHistory)
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> TextElementID
                                                                                                                             -> CreateComment
                                                                                                                             -> Handler
                                                                                                                                  Comment)
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> TextElementID
                                                                                                                                   -> Handler
                                                                                                                                        Comments)
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> TextElementID
                                                                                                                                         -> CommentID
                                                                                                                                         -> Handler
                                                                                                                                              ())
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> TextElementID
                                                                                                                                               -> CommentID
                                                                                                                                               -> CreateReply
                                                                                                                                               -> Handler
                                                                                                                                                    Message)
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> DocumentID
                                                                                                                                                     -> RevisionSelector
                                                                                                                                                     -> Handler
                                                                                                                                                          (FullDocument
                                                                                                                                                             TextElementRevision))
                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                             Token
                                                                                                                                                           -> DocumentID
                                                                                                                                                           -> RevisionSelector
                                                                                                                                                           -> Handler
                                                                                                                                                                PDFBytes)
                                                                                                                                                          :<|> ((AuthResult
                                                                                                                                                                   Token
                                                                                                                                                                 -> DocumentID
                                                                                                                                                                 -> RevisionSelector
                                                                                                                                                                 -> Handler
                                                                                                                                                                      ZipBytes)
                                                                                                                                                                :<|> ((AuthResult
                                                                                                                                                                         Token
                                                                                                                                                                       -> DocumentID
                                                                                                                                                                       -> RevisionSelector
                                                                                                                                                                       -> Handler
                                                                                                                                                                            (Maybe
                                                                                                                                                                               (TreeRevision
                                                                                                                                                                                  TextElement)))
                                                                                                                                                                      :<|> ((AuthResult
                                                                                                                                                                               Token
                                                                                                                                                                             -> DocumentID
                                                                                                                                                                             -> RevisionSelector
                                                                                                                                                                             -> TextElementID
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  (Maybe
                                                                                                                                                                                     TextElementRevision))
                                                                                                                                                                            :<|> ((AuthResult
                                                                                                                                                                                     Token
                                                                                                                                                                                   -> DocumentID
                                                                                                                                                                                   -> TextElementID
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        (Maybe
                                                                                                                                                                                           (Rendered
                                                                                                                                                                                              DraftRevision)))
                                                                                                                                                                                  :<|> ((AuthResult
                                                                                                                                                                                           Token
                                                                                                                                                                                         -> DocumentID
                                                                                                                                                                                         -> TextElementID
                                                                                                                                                                                         -> Handler
                                                                                                                                                                                              (Rendered
                                                                                                                                                                                                 ConflictStatus))
                                                                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                                                                 Token
                                                                                                                                                                                               -> DocumentID
                                                                                                                                                                                               -> TextElementID
                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                    ())
                                                                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                                                                       Token
                                                                                                                                                                                                     -> Text
                                                                                                                                                                                                     -> Handler
                                                                                                                                                                                                          DocByteString)
                                                                                                                                                                                                    :<|> (AuthResult
                                                                                                                                                                                                            Token
                                                                                                                                                                                                          -> Text
                                                                                                                                                                                                          -> Handler
                                                                                                                                                                                                               PDFByteString)))))))))))))))))))))))))))))
                                 :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                                        :<|> (AuthResult Token -> Text -> Handler PDFByteString))
                                       :<|> (AuthResult Token
                                             -> Maybe UTCTime
                                             -> Maybe GroupID
                                             -> Handler Logs)))))))
forall a b. a -> b -> a :<|> b
:<|> ( AuthResult Token -> Handler String
protectedHandler
                (AuthResult Token -> Handler String)
-> (((AuthResult Token -> UserRegisterData -> Handler UserID)
     :<|> (((AuthResult Token -> Handler FullUser)
            :<|> (AuthResult Token -> Text -> Handler NoContent))
           :<|> ((AuthResult Token -> Handler [User])
                 :<|> ((AuthResult Token -> UserID -> Handler FullUser)
                       :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                             :<|> (AuthResult Token
                                   -> UserID -> UserUpdate -> Handler NoContent))))))
    :<|> (((AuthResult Token -> GroupCreate -> Handler GroupID)
           :<|> ((AuthResult Token -> Handler [GroupOverview])
                 :<|> ((AuthResult Token -> GroupID -> Handler Group)
                       :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                             :<|> (AuthResult Token
                                   -> GroupID -> GroupPatch -> Handler GroupOverview)))))
          :<|> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
                 :<|> ((AuthResult Token
                        -> GroupID -> UserID -> Role -> Handler NoContent)
                       :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
                             :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                   :<|> (AuthResult Token -> UserID -> Handler NoContent)))))
                :<|> (((AuthResult Token
                        -> CreateDocument
                        -> Handler (FullDocument (Rendered TextElementRevision)))
                       :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                             :<|> ((AuthResult Token
                                    -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                                   :<|> ((AuthResult Token
                                          -> DocumentID -> CreateTextElement -> Handler TextElement)
                                         :<|> ((AuthResult Token
                                                -> DocumentID
                                                -> TextElementID
                                                -> Maybe Bool
                                                -> CreateTextRevision
                                                -> Handler (Rendered ConflictStatus))
                                               :<|> ((AuthResult Token
                                                      -> DocumentID
                                                      -> TextElementID
                                                      -> TextRevisionSelector
                                                      -> Handler
                                                           (Maybe (Rendered TextElementRevision)))
                                                     :<|> ((AuthResult Token
                                                            -> DocumentID
                                                            -> TextElementID
                                                            -> TextRevisionSelector
                                                            -> Handler PDFBytes)
                                                           :<|> ((AuthResult Token
                                                                  -> DocumentID
                                                                  -> Node TextElementID
                                                                  -> Handler
                                                                       (TreeRevisionWithMetaData
                                                                          TextElementID))
                                                                 :<|> ((AuthResult Token
                                                                        -> DocumentID
                                                                        -> TreeRevisionSelector
                                                                        -> Handler
                                                                             (Maybe
                                                                                (TreeRevisionWithMetaData
                                                                                   TextElement)))
                                                                       :<|> ((AuthResult Token
                                                                              -> DocumentID
                                                                              -> TreeRevisionSelector
                                                                              -> Handler
                                                                                   (Maybe
                                                                                      (TreeRevisionWithMetaData
                                                                                         TextElementRevision)))
                                                                             :<|> ((AuthResult Token
                                                                                    -> DocumentID
                                                                                    -> TreeRevisionSelector
                                                                                    -> Handler
                                                                                         PDFBytes)
                                                                                   :<|> ((AuthResult
                                                                                            Token
                                                                                          -> DocumentID
                                                                                          -> TreeRevisionSelector
                                                                                          -> Handler
                                                                                               ZipBytes)
                                                                                         :<|> ((AuthResult
                                                                                                  Token
                                                                                                -> DocumentID
                                                                                                -> TextElementID
                                                                                                -> Maybe
                                                                                                     UTCTime
                                                                                                -> Maybe
                                                                                                     UTCTime
                                                                                                -> Maybe
                                                                                                     GroupID
                                                                                                -> Handler
                                                                                                     TextRevisionHistory)
                                                                                               :<|> ((AuthResult
                                                                                                        Token
                                                                                                      -> DocumentID
                                                                                                      -> Maybe
                                                                                                           UTCTime
                                                                                                      -> Maybe
                                                                                                           GroupID
                                                                                                      -> Handler
                                                                                                           TreeRevisionHistory)
                                                                                                     :<|> ((AuthResult
                                                                                                              Token
                                                                                                            -> DocumentID
                                                                                                            -> Maybe
                                                                                                                 UTCTime
                                                                                                            -> Maybe
                                                                                                                 GroupID
                                                                                                            -> Handler
                                                                                                                 DocumentHistory)
                                                                                                           :<|> ((AuthResult
                                                                                                                    Token
                                                                                                                  -> DocumentID
                                                                                                                  -> TextElementID
                                                                                                                  -> CreateComment
                                                                                                                  -> Handler
                                                                                                                       Comment)
                                                                                                                 :<|> ((AuthResult
                                                                                                                          Token
                                                                                                                        -> DocumentID
                                                                                                                        -> TextElementID
                                                                                                                        -> Handler
                                                                                                                             Comments)
                                                                                                                       :<|> ((AuthResult
                                                                                                                                Token
                                                                                                                              -> DocumentID
                                                                                                                              -> TextElementID
                                                                                                                              -> CommentID
                                                                                                                              -> Handler
                                                                                                                                   ())
                                                                                                                             :<|> ((AuthResult
                                                                                                                                      Token
                                                                                                                                    -> DocumentID
                                                                                                                                    -> TextElementID
                                                                                                                                    -> CommentID
                                                                                                                                    -> CreateReply
                                                                                                                                    -> Handler
                                                                                                                                         Message)
                                                                                                                                   :<|> ((AuthResult
                                                                                                                                            Token
                                                                                                                                          -> DocumentID
                                                                                                                                          -> RevisionSelector
                                                                                                                                          -> Handler
                                                                                                                                               (FullDocument
                                                                                                                                                  TextElementRevision))
                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                  Token
                                                                                                                                                -> DocumentID
                                                                                                                                                -> RevisionSelector
                                                                                                                                                -> Handler
                                                                                                                                                     PDFBytes)
                                                                                                                                               :<|> ((AuthResult
                                                                                                                                                        Token
                                                                                                                                                      -> DocumentID
                                                                                                                                                      -> RevisionSelector
                                                                                                                                                      -> Handler
                                                                                                                                                           ZipBytes)
                                                                                                                                                     :<|> ((AuthResult
                                                                                                                                                              Token
                                                                                                                                                            -> DocumentID
                                                                                                                                                            -> RevisionSelector
                                                                                                                                                            -> Handler
                                                                                                                                                                 (Maybe
                                                                                                                                                                    (TreeRevision
                                                                                                                                                                       TextElement)))
                                                                                                                                                           :<|> ((AuthResult
                                                                                                                                                                    Token
                                                                                                                                                                  -> DocumentID
                                                                                                                                                                  -> RevisionSelector
                                                                                                                                                                  -> TextElementID
                                                                                                                                                                  -> Handler
                                                                                                                                                                       (Maybe
                                                                                                                                                                          TextElementRevision))
                                                                                                                                                                 :<|> ((AuthResult
                                                                                                                                                                          Token
                                                                                                                                                                        -> DocumentID
                                                                                                                                                                        -> TextElementID
                                                                                                                                                                        -> Handler
                                                                                                                                                                             (Maybe
                                                                                                                                                                                (Rendered
                                                                                                                                                                                   DraftRevision)))
                                                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                                                Token
                                                                                                                                                                              -> DocumentID
                                                                                                                                                                              -> TextElementID
                                                                                                                                                                              -> Handler
                                                                                                                                                                                   (Rendered
                                                                                                                                                                                      ConflictStatus))
                                                                                                                                                                             :<|> ((AuthResult
                                                                                                                                                                                      Token
                                                                                                                                                                                    -> DocumentID
                                                                                                                                                                                    -> TextElementID
                                                                                                                                                                                    -> Handler
                                                                                                                                                                                         ())
                                                                                                                                                                                   :<|> ((AuthResult
                                                                                                                                                                                            Token
                                                                                                                                                                                          -> Text
                                                                                                                                                                                          -> Handler
                                                                                                                                                                                               DocByteString)
                                                                                                                                                                                         :<|> (AuthResult
                                                                                                                                                                                                 Token
                                                                                                                                                                                               -> Text
                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                    PDFByteString)))))))))))))))))))))))))))))
                      :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                             :<|> (AuthResult Token -> Text -> Handler PDFByteString))
                            :<|> (AuthResult Token
                                  -> Maybe UTCTime -> Maybe GroupID -> Handler Logs))))))
-> (AuthResult Token -> Handler String)
   :<|> (((AuthResult Token -> UserRegisterData -> Handler UserID)
          :<|> (((AuthResult Token -> Handler FullUser)
                 :<|> (AuthResult Token -> Text -> Handler NoContent))
                :<|> ((AuthResult Token -> Handler [User])
                      :<|> ((AuthResult Token -> UserID -> Handler FullUser)
                            :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                  :<|> (AuthResult Token
                                        -> UserID -> UserUpdate -> Handler NoContent))))))
         :<|> (((AuthResult Token -> GroupCreate -> Handler GroupID)
                :<|> ((AuthResult Token -> Handler [GroupOverview])
                      :<|> ((AuthResult Token -> GroupID -> Handler Group)
                            :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                                  :<|> (AuthResult Token
                                        -> GroupID -> GroupPatch -> Handler GroupOverview)))))
               :<|> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
                      :<|> ((AuthResult Token
                             -> GroupID -> UserID -> Role -> Handler NoContent)
                            :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
                                  :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                        :<|> (AuthResult Token -> UserID -> Handler NoContent)))))
                     :<|> (((AuthResult Token
                             -> CreateDocument
                             -> Handler (FullDocument (Rendered TextElementRevision)))
                            :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                                  :<|> ((AuthResult Token
                                         -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> CreateTextElement
                                               -> Handler TextElement)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> Maybe Bool
                                                     -> CreateTextRevision
                                                     -> Handler (Rendered ConflictStatus))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> TextRevisionSelector
                                                           -> Handler
                                                                (Maybe
                                                                   (Rendered TextElementRevision)))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> TextRevisionSelector
                                                                 -> Handler PDFBytes)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> Node TextElementID
                                                                       -> Handler
                                                                            (TreeRevisionWithMetaData
                                                                               TextElementID))
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TreeRevisionSelector
                                                                             -> Handler
                                                                                  (Maybe
                                                                                     (TreeRevisionWithMetaData
                                                                                        TextElement)))
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TreeRevisionSelector
                                                                                   -> Handler
                                                                                        (Maybe
                                                                                           (TreeRevisionWithMetaData
                                                                                              TextElementRevision)))
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TreeRevisionSelector
                                                                                         -> Handler
                                                                                              PDFBytes)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TreeRevisionSelector
                                                                                               -> Handler
                                                                                                    ZipBytes)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TextElementID
                                                                                                     -> Maybe
                                                                                                          UTCTime
                                                                                                     -> Maybe
                                                                                                          UTCTime
                                                                                                     -> Maybe
                                                                                                          GroupID
                                                                                                     -> Handler
                                                                                                          TextRevisionHistory)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> Maybe
                                                                                                                UTCTime
                                                                                                           -> Maybe
                                                                                                                GroupID
                                                                                                           -> Handler
                                                                                                                TreeRevisionHistory)
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> Maybe
                                                                                                                      UTCTime
                                                                                                                 -> Maybe
                                                                                                                      GroupID
                                                                                                                 -> Handler
                                                                                                                      DocumentHistory)
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> TextElementID
                                                                                                                       -> CreateComment
                                                                                                                       -> Handler
                                                                                                                            Comment)
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> TextElementID
                                                                                                                             -> Handler
                                                                                                                                  Comments)
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> TextElementID
                                                                                                                                   -> CommentID
                                                                                                                                   -> Handler
                                                                                                                                        ())
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> TextElementID
                                                                                                                                         -> CommentID
                                                                                                                                         -> CreateReply
                                                                                                                                         -> Handler
                                                                                                                                              Message)
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> RevisionSelector
                                                                                                                                               -> Handler
                                                                                                                                                    (FullDocument
                                                                                                                                                       TextElementRevision))
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> DocumentID
                                                                                                                                                     -> RevisionSelector
                                                                                                                                                     -> Handler
                                                                                                                                                          PDFBytes)
                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                             Token
                                                                                                                                                           -> DocumentID
                                                                                                                                                           -> RevisionSelector
                                                                                                                                                           -> Handler
                                                                                                                                                                ZipBytes)
                                                                                                                                                          :<|> ((AuthResult
                                                                                                                                                                   Token
                                                                                                                                                                 -> DocumentID
                                                                                                                                                                 -> RevisionSelector
                                                                                                                                                                 -> Handler
                                                                                                                                                                      (Maybe
                                                                                                                                                                         (TreeRevision
                                                                                                                                                                            TextElement)))
                                                                                                                                                                :<|> ((AuthResult
                                                                                                                                                                         Token
                                                                                                                                                                       -> DocumentID
                                                                                                                                                                       -> RevisionSelector
                                                                                                                                                                       -> TextElementID
                                                                                                                                                                       -> Handler
                                                                                                                                                                            (Maybe
                                                                                                                                                                               TextElementRevision))
                                                                                                                                                                      :<|> ((AuthResult
                                                                                                                                                                               Token
                                                                                                                                                                             -> DocumentID
                                                                                                                                                                             -> TextElementID
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  (Maybe
                                                                                                                                                                                     (Rendered
                                                                                                                                                                                        DraftRevision)))
                                                                                                                                                                            :<|> ((AuthResult
                                                                                                                                                                                     Token
                                                                                                                                                                                   -> DocumentID
                                                                                                                                                                                   -> TextElementID
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        (Rendered
                                                                                                                                                                                           ConflictStatus))
                                                                                                                                                                                  :<|> ((AuthResult
                                                                                                                                                                                           Token
                                                                                                                                                                                         -> DocumentID
                                                                                                                                                                                         -> TextElementID
                                                                                                                                                                                         -> Handler
                                                                                                                                                                                              ())
                                                                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                                                                 Token
                                                                                                                                                                                               -> Text
                                                                                                                                                                                               -> Handler
                                                                                                                                                                                                    DocByteString)
                                                                                                                                                                                              :<|> (AuthResult
                                                                                                                                                                                                      Token
                                                                                                                                                                                                    -> Text
                                                                                                                                                                                                    -> Handler
                                                                                                                                                                                                         PDFByteString)))))))))))))))))))))))))))))
                           :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                                  :<|> (AuthResult Token -> Text -> Handler PDFByteString))
                                 :<|> (AuthResult Token
                                       -> Maybe UTCTime -> Maybe GroupID -> Handler Logs))))))
forall a b. a -> b -> a :<|> b
:<|> (AuthResult Token -> UserRegisterData -> Handler UserID)
:<|> (((AuthResult Token -> Handler FullUser)
       :<|> (AuthResult Token -> Text -> Handler NoContent))
      :<|> ((AuthResult Token -> Handler [User])
            :<|> ((AuthResult Token -> UserID -> Handler FullUser)
                  :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                        :<|> (AuthResult Token
                              -> UserID -> UserUpdate -> Handler NoContent)))))
Server UserAPI
userServer
                ((AuthResult Token -> UserRegisterData -> Handler UserID)
 :<|> (((AuthResult Token -> Handler FullUser)
        :<|> (AuthResult Token -> Text -> Handler NoContent))
       :<|> ((AuthResult Token -> Handler [User])
             :<|> ((AuthResult Token -> UserID -> Handler FullUser)
                   :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                         :<|> (AuthResult Token
                               -> UserID -> UserUpdate -> Handler NoContent))))))
-> (((AuthResult Token -> GroupCreate -> Handler GroupID)
     :<|> ((AuthResult Token -> Handler [GroupOverview])
           :<|> ((AuthResult Token -> GroupID -> Handler Group)
                 :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                       :<|> (AuthResult Token
                             -> GroupID -> GroupPatch -> Handler GroupOverview)))))
    :<|> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
           :<|> ((AuthResult Token
                  -> GroupID -> UserID -> Role -> Handler NoContent)
                 :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
                       :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                             :<|> (AuthResult Token -> UserID -> Handler NoContent)))))
          :<|> (((AuthResult Token
                  -> CreateDocument
                  -> Handler (FullDocument (Rendered TextElementRevision)))
                 :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                       :<|> ((AuthResult Token
                              -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                             :<|> ((AuthResult Token
                                    -> DocumentID -> CreateTextElement -> Handler TextElement)
                                   :<|> ((AuthResult Token
                                          -> DocumentID
                                          -> TextElementID
                                          -> Maybe Bool
                                          -> CreateTextRevision
                                          -> Handler (Rendered ConflictStatus))
                                         :<|> ((AuthResult Token
                                                -> DocumentID
                                                -> TextElementID
                                                -> TextRevisionSelector
                                                -> Handler (Maybe (Rendered TextElementRevision)))
                                               :<|> ((AuthResult Token
                                                      -> DocumentID
                                                      -> TextElementID
                                                      -> TextRevisionSelector
                                                      -> Handler PDFBytes)
                                                     :<|> ((AuthResult Token
                                                            -> DocumentID
                                                            -> Node TextElementID
                                                            -> Handler
                                                                 (TreeRevisionWithMetaData
                                                                    TextElementID))
                                                           :<|> ((AuthResult Token
                                                                  -> DocumentID
                                                                  -> TreeRevisionSelector
                                                                  -> Handler
                                                                       (Maybe
                                                                          (TreeRevisionWithMetaData
                                                                             TextElement)))
                                                                 :<|> ((AuthResult Token
                                                                        -> DocumentID
                                                                        -> TreeRevisionSelector
                                                                        -> Handler
                                                                             (Maybe
                                                                                (TreeRevisionWithMetaData
                                                                                   TextElementRevision)))
                                                                       :<|> ((AuthResult Token
                                                                              -> DocumentID
                                                                              -> TreeRevisionSelector
                                                                              -> Handler PDFBytes)
                                                                             :<|> ((AuthResult Token
                                                                                    -> DocumentID
                                                                                    -> TreeRevisionSelector
                                                                                    -> Handler
                                                                                         ZipBytes)
                                                                                   :<|> ((AuthResult
                                                                                            Token
                                                                                          -> DocumentID
                                                                                          -> TextElementID
                                                                                          -> Maybe
                                                                                               UTCTime
                                                                                          -> Maybe
                                                                                               UTCTime
                                                                                          -> Maybe
                                                                                               GroupID
                                                                                          -> Handler
                                                                                               TextRevisionHistory)
                                                                                         :<|> ((AuthResult
                                                                                                  Token
                                                                                                -> DocumentID
                                                                                                -> Maybe
                                                                                                     UTCTime
                                                                                                -> Maybe
                                                                                                     GroupID
                                                                                                -> Handler
                                                                                                     TreeRevisionHistory)
                                                                                               :<|> ((AuthResult
                                                                                                        Token
                                                                                                      -> DocumentID
                                                                                                      -> Maybe
                                                                                                           UTCTime
                                                                                                      -> Maybe
                                                                                                           GroupID
                                                                                                      -> Handler
                                                                                                           DocumentHistory)
                                                                                                     :<|> ((AuthResult
                                                                                                              Token
                                                                                                            -> DocumentID
                                                                                                            -> TextElementID
                                                                                                            -> CreateComment
                                                                                                            -> Handler
                                                                                                                 Comment)
                                                                                                           :<|> ((AuthResult
                                                                                                                    Token
                                                                                                                  -> DocumentID
                                                                                                                  -> TextElementID
                                                                                                                  -> Handler
                                                                                                                       Comments)
                                                                                                                 :<|> ((AuthResult
                                                                                                                          Token
                                                                                                                        -> DocumentID
                                                                                                                        -> TextElementID
                                                                                                                        -> CommentID
                                                                                                                        -> Handler
                                                                                                                             ())
                                                                                                                       :<|> ((AuthResult
                                                                                                                                Token
                                                                                                                              -> DocumentID
                                                                                                                              -> TextElementID
                                                                                                                              -> CommentID
                                                                                                                              -> CreateReply
                                                                                                                              -> Handler
                                                                                                                                   Message)
                                                                                                                             :<|> ((AuthResult
                                                                                                                                      Token
                                                                                                                                    -> DocumentID
                                                                                                                                    -> RevisionSelector
                                                                                                                                    -> Handler
                                                                                                                                         (FullDocument
                                                                                                                                            TextElementRevision))
                                                                                                                                   :<|> ((AuthResult
                                                                                                                                            Token
                                                                                                                                          -> DocumentID
                                                                                                                                          -> RevisionSelector
                                                                                                                                          -> Handler
                                                                                                                                               PDFBytes)
                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                  Token
                                                                                                                                                -> DocumentID
                                                                                                                                                -> RevisionSelector
                                                                                                                                                -> Handler
                                                                                                                                                     ZipBytes)
                                                                                                                                               :<|> ((AuthResult
                                                                                                                                                        Token
                                                                                                                                                      -> DocumentID
                                                                                                                                                      -> RevisionSelector
                                                                                                                                                      -> Handler
                                                                                                                                                           (Maybe
                                                                                                                                                              (TreeRevision
                                                                                                                                                                 TextElement)))
                                                                                                                                                     :<|> ((AuthResult
                                                                                                                                                              Token
                                                                                                                                                            -> DocumentID
                                                                                                                                                            -> RevisionSelector
                                                                                                                                                            -> TextElementID
                                                                                                                                                            -> Handler
                                                                                                                                                                 (Maybe
                                                                                                                                                                    TextElementRevision))
                                                                                                                                                           :<|> ((AuthResult
                                                                                                                                                                    Token
                                                                                                                                                                  -> DocumentID
                                                                                                                                                                  -> TextElementID
                                                                                                                                                                  -> Handler
                                                                                                                                                                       (Maybe
                                                                                                                                                                          (Rendered
                                                                                                                                                                             DraftRevision)))
                                                                                                                                                                 :<|> ((AuthResult
                                                                                                                                                                          Token
                                                                                                                                                                        -> DocumentID
                                                                                                                                                                        -> TextElementID
                                                                                                                                                                        -> Handler
                                                                                                                                                                             (Rendered
                                                                                                                                                                                ConflictStatus))
                                                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                                                Token
                                                                                                                                                                              -> DocumentID
                                                                                                                                                                              -> TextElementID
                                                                                                                                                                              -> Handler
                                                                                                                                                                                   ())
                                                                                                                                                                             :<|> ((AuthResult
                                                                                                                                                                                      Token
                                                                                                                                                                                    -> Text
                                                                                                                                                                                    -> Handler
                                                                                                                                                                                         DocByteString)
                                                                                                                                                                                   :<|> (AuthResult
                                                                                                                                                                                           Token
                                                                                                                                                                                         -> Text
                                                                                                                                                                                         -> Handler
                                                                                                                                                                                              PDFByteString)))))))))))))))))))))))))))))
                :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                       :<|> (AuthResult Token -> Text -> Handler PDFByteString))
                      :<|> (AuthResult Token
                            -> Maybe UTCTime -> Maybe GroupID -> Handler Logs)))))
-> ((AuthResult Token -> UserRegisterData -> Handler UserID)
    :<|> (((AuthResult Token -> Handler FullUser)
           :<|> (AuthResult Token -> Text -> Handler NoContent))
          :<|> ((AuthResult Token -> Handler [User])
                :<|> ((AuthResult Token -> UserID -> Handler FullUser)
                      :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                            :<|> (AuthResult Token
                                  -> UserID -> UserUpdate -> Handler NoContent))))))
   :<|> (((AuthResult Token -> GroupCreate -> Handler GroupID)
          :<|> ((AuthResult Token -> Handler [GroupOverview])
                :<|> ((AuthResult Token -> GroupID -> Handler Group)
                      :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                            :<|> (AuthResult Token
                                  -> GroupID -> GroupPatch -> Handler GroupOverview)))))
         :<|> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
                :<|> ((AuthResult Token
                       -> GroupID -> UserID -> Role -> Handler NoContent)
                      :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
                            :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                                  :<|> (AuthResult Token -> UserID -> Handler NoContent)))))
               :<|> (((AuthResult Token
                       -> CreateDocument
                       -> Handler (FullDocument (Rendered TextElementRevision)))
                      :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                            :<|> ((AuthResult Token
                                   -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                                  :<|> ((AuthResult Token
                                         -> DocumentID -> CreateTextElement -> Handler TextElement)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TextElementID
                                               -> Maybe Bool
                                               -> CreateTextRevision
                                               -> Handler (Rendered ConflictStatus))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> TextRevisionSelector
                                                     -> Handler
                                                          (Maybe (Rendered TextElementRevision)))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> TextRevisionSelector
                                                           -> Handler PDFBytes)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> Node TextElementID
                                                                 -> Handler
                                                                      (TreeRevisionWithMetaData
                                                                         TextElementID))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TreeRevisionSelector
                                                                       -> Handler
                                                                            (Maybe
                                                                               (TreeRevisionWithMetaData
                                                                                  TextElement)))
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TreeRevisionSelector
                                                                             -> Handler
                                                                                  (Maybe
                                                                                     (TreeRevisionWithMetaData
                                                                                        TextElementRevision)))
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TreeRevisionSelector
                                                                                   -> Handler
                                                                                        PDFBytes)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TreeRevisionSelector
                                                                                         -> Handler
                                                                                              ZipBytes)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TextElementID
                                                                                               -> Maybe
                                                                                                    UTCTime
                                                                                               -> Maybe
                                                                                                    UTCTime
                                                                                               -> Maybe
                                                                                                    GroupID
                                                                                               -> Handler
                                                                                                    TextRevisionHistory)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> Maybe
                                                                                                          UTCTime
                                                                                                     -> Maybe
                                                                                                          GroupID
                                                                                                     -> Handler
                                                                                                          TreeRevisionHistory)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> Maybe
                                                                                                                UTCTime
                                                                                                           -> Maybe
                                                                                                                GroupID
                                                                                                           -> Handler
                                                                                                                DocumentHistory)
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> TextElementID
                                                                                                                 -> CreateComment
                                                                                                                 -> Handler
                                                                                                                      Comment)
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> TextElementID
                                                                                                                       -> Handler
                                                                                                                            Comments)
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> TextElementID
                                                                                                                             -> CommentID
                                                                                                                             -> Handler
                                                                                                                                  ())
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> TextElementID
                                                                                                                                   -> CommentID
                                                                                                                                   -> CreateReply
                                                                                                                                   -> Handler
                                                                                                                                        Message)
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> RevisionSelector
                                                                                                                                         -> Handler
                                                                                                                                              (FullDocument
                                                                                                                                                 TextElementRevision))
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> RevisionSelector
                                                                                                                                               -> Handler
                                                                                                                                                    PDFBytes)
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> DocumentID
                                                                                                                                                     -> RevisionSelector
                                                                                                                                                     -> Handler
                                                                                                                                                          ZipBytes)
                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                             Token
                                                                                                                                                           -> DocumentID
                                                                                                                                                           -> RevisionSelector
                                                                                                                                                           -> Handler
                                                                                                                                                                (Maybe
                                                                                                                                                                   (TreeRevision
                                                                                                                                                                      TextElement)))
                                                                                                                                                          :<|> ((AuthResult
                                                                                                                                                                   Token
                                                                                                                                                                 -> DocumentID
                                                                                                                                                                 -> RevisionSelector
                                                                                                                                                                 -> TextElementID
                                                                                                                                                                 -> Handler
                                                                                                                                                                      (Maybe
                                                                                                                                                                         TextElementRevision))
                                                                                                                                                                :<|> ((AuthResult
                                                                                                                                                                         Token
                                                                                                                                                                       -> DocumentID
                                                                                                                                                                       -> TextElementID
                                                                                                                                                                       -> Handler
                                                                                                                                                                            (Maybe
                                                                                                                                                                               (Rendered
                                                                                                                                                                                  DraftRevision)))
                                                                                                                                                                      :<|> ((AuthResult
                                                                                                                                                                               Token
                                                                                                                                                                             -> DocumentID
                                                                                                                                                                             -> TextElementID
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  (Rendered
                                                                                                                                                                                     ConflictStatus))
                                                                                                                                                                            :<|> ((AuthResult
                                                                                                                                                                                     Token
                                                                                                                                                                                   -> DocumentID
                                                                                                                                                                                   -> TextElementID
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        ())
                                                                                                                                                                                  :<|> ((AuthResult
                                                                                                                                                                                           Token
                                                                                                                                                                                         -> Text
                                                                                                                                                                                         -> Handler
                                                                                                                                                                                              DocByteString)
                                                                                                                                                                                        :<|> (AuthResult
                                                                                                                                                                                                Token
                                                                                                                                                                                              -> Text
                                                                                                                                                                                              -> Handler
                                                                                                                                                                                                   PDFByteString)))))))))))))))))))))))))))))
                     :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                            :<|> (AuthResult Token -> Text -> Handler PDFByteString))
                           :<|> (AuthResult Token
                                 -> Maybe UTCTime -> Maybe GroupID -> Handler Logs)))))
forall a b. a -> b -> a :<|> b
:<|> (AuthResult Token -> GroupCreate -> Handler GroupID)
:<|> ((AuthResult Token -> Handler [GroupOverview])
      :<|> ((AuthResult Token -> GroupID -> Handler Group)
            :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                  :<|> (AuthResult Token
                        -> GroupID -> GroupPatch -> Handler GroupOverview))))
Server GroupAPI
groupServer
                ((AuthResult Token -> GroupCreate -> Handler GroupID)
 :<|> ((AuthResult Token -> Handler [GroupOverview])
       :<|> ((AuthResult Token -> GroupID -> Handler Group)
             :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                   :<|> (AuthResult Token
                         -> GroupID -> GroupPatch -> Handler GroupOverview)))))
-> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
     :<|> ((AuthResult Token
            -> GroupID -> UserID -> Role -> Handler NoContent)
           :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
                 :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                       :<|> (AuthResult Token -> UserID -> Handler NoContent)))))
    :<|> (((AuthResult Token
            -> CreateDocument
            -> Handler (FullDocument (Rendered TextElementRevision)))
           :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                 :<|> ((AuthResult Token
                        -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                       :<|> ((AuthResult Token
                              -> DocumentID -> CreateTextElement -> Handler TextElement)
                             :<|> ((AuthResult Token
                                    -> DocumentID
                                    -> TextElementID
                                    -> Maybe Bool
                                    -> CreateTextRevision
                                    -> Handler (Rendered ConflictStatus))
                                   :<|> ((AuthResult Token
                                          -> DocumentID
                                          -> TextElementID
                                          -> TextRevisionSelector
                                          -> Handler (Maybe (Rendered TextElementRevision)))
                                         :<|> ((AuthResult Token
                                                -> DocumentID
                                                -> TextElementID
                                                -> TextRevisionSelector
                                                -> Handler PDFBytes)
                                               :<|> ((AuthResult Token
                                                      -> DocumentID
                                                      -> Node TextElementID
                                                      -> Handler
                                                           (TreeRevisionWithMetaData TextElementID))
                                                     :<|> ((AuthResult Token
                                                            -> DocumentID
                                                            -> TreeRevisionSelector
                                                            -> Handler
                                                                 (Maybe
                                                                    (TreeRevisionWithMetaData
                                                                       TextElement)))
                                                           :<|> ((AuthResult Token
                                                                  -> DocumentID
                                                                  -> TreeRevisionSelector
                                                                  -> Handler
                                                                       (Maybe
                                                                          (TreeRevisionWithMetaData
                                                                             TextElementRevision)))
                                                                 :<|> ((AuthResult Token
                                                                        -> DocumentID
                                                                        -> TreeRevisionSelector
                                                                        -> Handler PDFBytes)
                                                                       :<|> ((AuthResult Token
                                                                              -> DocumentID
                                                                              -> TreeRevisionSelector
                                                                              -> Handler ZipBytes)
                                                                             :<|> ((AuthResult Token
                                                                                    -> DocumentID
                                                                                    -> TextElementID
                                                                                    -> Maybe UTCTime
                                                                                    -> Maybe UTCTime
                                                                                    -> Maybe GroupID
                                                                                    -> Handler
                                                                                         TextRevisionHistory)
                                                                                   :<|> ((AuthResult
                                                                                            Token
                                                                                          -> DocumentID
                                                                                          -> Maybe
                                                                                               UTCTime
                                                                                          -> Maybe
                                                                                               GroupID
                                                                                          -> Handler
                                                                                               TreeRevisionHistory)
                                                                                         :<|> ((AuthResult
                                                                                                  Token
                                                                                                -> DocumentID
                                                                                                -> Maybe
                                                                                                     UTCTime
                                                                                                -> Maybe
                                                                                                     GroupID
                                                                                                -> Handler
                                                                                                     DocumentHistory)
                                                                                               :<|> ((AuthResult
                                                                                                        Token
                                                                                                      -> DocumentID
                                                                                                      -> TextElementID
                                                                                                      -> CreateComment
                                                                                                      -> Handler
                                                                                                           Comment)
                                                                                                     :<|> ((AuthResult
                                                                                                              Token
                                                                                                            -> DocumentID
                                                                                                            -> TextElementID
                                                                                                            -> Handler
                                                                                                                 Comments)
                                                                                                           :<|> ((AuthResult
                                                                                                                    Token
                                                                                                                  -> DocumentID
                                                                                                                  -> TextElementID
                                                                                                                  -> CommentID
                                                                                                                  -> Handler
                                                                                                                       ())
                                                                                                                 :<|> ((AuthResult
                                                                                                                          Token
                                                                                                                        -> DocumentID
                                                                                                                        -> TextElementID
                                                                                                                        -> CommentID
                                                                                                                        -> CreateReply
                                                                                                                        -> Handler
                                                                                                                             Message)
                                                                                                                       :<|> ((AuthResult
                                                                                                                                Token
                                                                                                                              -> DocumentID
                                                                                                                              -> RevisionSelector
                                                                                                                              -> Handler
                                                                                                                                   (FullDocument
                                                                                                                                      TextElementRevision))
                                                                                                                             :<|> ((AuthResult
                                                                                                                                      Token
                                                                                                                                    -> DocumentID
                                                                                                                                    -> RevisionSelector
                                                                                                                                    -> Handler
                                                                                                                                         PDFBytes)
                                                                                                                                   :<|> ((AuthResult
                                                                                                                                            Token
                                                                                                                                          -> DocumentID
                                                                                                                                          -> RevisionSelector
                                                                                                                                          -> Handler
                                                                                                                                               ZipBytes)
                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                  Token
                                                                                                                                                -> DocumentID
                                                                                                                                                -> RevisionSelector
                                                                                                                                                -> Handler
                                                                                                                                                     (Maybe
                                                                                                                                                        (TreeRevision
                                                                                                                                                           TextElement)))
                                                                                                                                               :<|> ((AuthResult
                                                                                                                                                        Token
                                                                                                                                                      -> DocumentID
                                                                                                                                                      -> RevisionSelector
                                                                                                                                                      -> TextElementID
                                                                                                                                                      -> Handler
                                                                                                                                                           (Maybe
                                                                                                                                                              TextElementRevision))
                                                                                                                                                     :<|> ((AuthResult
                                                                                                                                                              Token
                                                                                                                                                            -> DocumentID
                                                                                                                                                            -> TextElementID
                                                                                                                                                            -> Handler
                                                                                                                                                                 (Maybe
                                                                                                                                                                    (Rendered
                                                                                                                                                                       DraftRevision)))
                                                                                                                                                           :<|> ((AuthResult
                                                                                                                                                                    Token
                                                                                                                                                                  -> DocumentID
                                                                                                                                                                  -> TextElementID
                                                                                                                                                                  -> Handler
                                                                                                                                                                       (Rendered
                                                                                                                                                                          ConflictStatus))
                                                                                                                                                                 :<|> ((AuthResult
                                                                                                                                                                          Token
                                                                                                                                                                        -> DocumentID
                                                                                                                                                                        -> TextElementID
                                                                                                                                                                        -> Handler
                                                                                                                                                                             ())
                                                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                                                Token
                                                                                                                                                                              -> Text
                                                                                                                                                                              -> Handler
                                                                                                                                                                                   DocByteString)
                                                                                                                                                                             :<|> (AuthResult
                                                                                                                                                                                     Token
                                                                                                                                                                                   -> Text
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        PDFByteString)))))))))))))))))))))))))))))
          :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                 :<|> (AuthResult Token -> Text -> Handler PDFByteString))
                :<|> (AuthResult Token
                      -> Maybe UTCTime -> Maybe GroupID -> Handler Logs))))
-> ((AuthResult Token -> GroupCreate -> Handler GroupID)
    :<|> ((AuthResult Token -> Handler [GroupOverview])
          :<|> ((AuthResult Token -> GroupID -> Handler Group)
                :<|> ((AuthResult Token -> GroupID -> Handler NoContent)
                      :<|> (AuthResult Token
                            -> GroupID -> GroupPatch -> Handler GroupOverview)))))
   :<|> (((AuthResult Token -> GroupID -> UserID -> Handler Role)
          :<|> ((AuthResult Token
                 -> GroupID -> UserID -> Role -> Handler NoContent)
                :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
                      :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                            :<|> (AuthResult Token -> UserID -> Handler NoContent)))))
         :<|> (((AuthResult Token
                 -> CreateDocument
                 -> Handler (FullDocument (Rendered TextElementRevision)))
                :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                      :<|> ((AuthResult Token
                             -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                            :<|> ((AuthResult Token
                                   -> DocumentID -> CreateTextElement -> Handler TextElement)
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TextElementID
                                         -> Maybe Bool
                                         -> CreateTextRevision
                                         -> Handler (Rendered ConflictStatus))
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TextElementID
                                               -> TextRevisionSelector
                                               -> Handler (Maybe (Rendered TextElementRevision)))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> TextRevisionSelector
                                                     -> Handler PDFBytes)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> Node TextElementID
                                                           -> Handler
                                                                (TreeRevisionWithMetaData
                                                                   TextElementID))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TreeRevisionSelector
                                                                 -> Handler
                                                                      (Maybe
                                                                         (TreeRevisionWithMetaData
                                                                            TextElement)))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TreeRevisionSelector
                                                                       -> Handler
                                                                            (Maybe
                                                                               (TreeRevisionWithMetaData
                                                                                  TextElementRevision)))
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TreeRevisionSelector
                                                                             -> Handler PDFBytes)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TreeRevisionSelector
                                                                                   -> Handler
                                                                                        ZipBytes)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TextElementID
                                                                                         -> Maybe
                                                                                              UTCTime
                                                                                         -> Maybe
                                                                                              UTCTime
                                                                                         -> Maybe
                                                                                              GroupID
                                                                                         -> Handler
                                                                                              TextRevisionHistory)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> Maybe
                                                                                                    UTCTime
                                                                                               -> Maybe
                                                                                                    GroupID
                                                                                               -> Handler
                                                                                                    TreeRevisionHistory)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> Maybe
                                                                                                          UTCTime
                                                                                                     -> Maybe
                                                                                                          GroupID
                                                                                                     -> Handler
                                                                                                          DocumentHistory)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> TextElementID
                                                                                                           -> CreateComment
                                                                                                           -> Handler
                                                                                                                Comment)
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> TextElementID
                                                                                                                 -> Handler
                                                                                                                      Comments)
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> TextElementID
                                                                                                                       -> CommentID
                                                                                                                       -> Handler
                                                                                                                            ())
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> TextElementID
                                                                                                                             -> CommentID
                                                                                                                             -> CreateReply
                                                                                                                             -> Handler
                                                                                                                                  Message)
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> RevisionSelector
                                                                                                                                   -> Handler
                                                                                                                                        (FullDocument
                                                                                                                                           TextElementRevision))
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> RevisionSelector
                                                                                                                                         -> Handler
                                                                                                                                              PDFBytes)
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> RevisionSelector
                                                                                                                                               -> Handler
                                                                                                                                                    ZipBytes)
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> DocumentID
                                                                                                                                                     -> RevisionSelector
                                                                                                                                                     -> Handler
                                                                                                                                                          (Maybe
                                                                                                                                                             (TreeRevision
                                                                                                                                                                TextElement)))
                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                             Token
                                                                                                                                                           -> DocumentID
                                                                                                                                                           -> RevisionSelector
                                                                                                                                                           -> TextElementID
                                                                                                                                                           -> Handler
                                                                                                                                                                (Maybe
                                                                                                                                                                   TextElementRevision))
                                                                                                                                                          :<|> ((AuthResult
                                                                                                                                                                   Token
                                                                                                                                                                 -> DocumentID
                                                                                                                                                                 -> TextElementID
                                                                                                                                                                 -> Handler
                                                                                                                                                                      (Maybe
                                                                                                                                                                         (Rendered
                                                                                                                                                                            DraftRevision)))
                                                                                                                                                                :<|> ((AuthResult
                                                                                                                                                                         Token
                                                                                                                                                                       -> DocumentID
                                                                                                                                                                       -> TextElementID
                                                                                                                                                                       -> Handler
                                                                                                                                                                            (Rendered
                                                                                                                                                                               ConflictStatus))
                                                                                                                                                                      :<|> ((AuthResult
                                                                                                                                                                               Token
                                                                                                                                                                             -> DocumentID
                                                                                                                                                                             -> TextElementID
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  ())
                                                                                                                                                                            :<|> ((AuthResult
                                                                                                                                                                                     Token
                                                                                                                                                                                   -> Text
                                                                                                                                                                                   -> Handler
                                                                                                                                                                                        DocByteString)
                                                                                                                                                                                  :<|> (AuthResult
                                                                                                                                                                                          Token
                                                                                                                                                                                        -> Text
                                                                                                                                                                                        -> Handler
                                                                                                                                                                                             PDFByteString)))))))))))))))))))))))))))))
               :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                      :<|> (AuthResult Token -> Text -> Handler PDFByteString))
                     :<|> (AuthResult Token
                           -> Maybe UTCTime -> Maybe GroupID -> Handler Logs))))
forall a b. a -> b -> a :<|> b
:<|> (AuthResult Token -> GroupID -> UserID -> Handler Role)
:<|> ((AuthResult Token
       -> GroupID -> UserID -> Role -> Handler NoContent)
      :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
            :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                  :<|> (AuthResult Token -> UserID -> Handler NoContent))))
Server RoleAPI
roleServer
                ((AuthResult Token -> GroupID -> UserID -> Handler Role)
 :<|> ((AuthResult Token
        -> GroupID -> UserID -> Role -> Handler NoContent)
       :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
             :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                   :<|> (AuthResult Token -> UserID -> Handler NoContent)))))
-> (((AuthResult Token
      -> CreateDocument
      -> Handler (FullDocument (Rendered TextElementRevision)))
     :<|> ((AuthResult Token -> DocumentID -> Handler Document)
           :<|> ((AuthResult Token
                  -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                 :<|> ((AuthResult Token
                        -> DocumentID -> CreateTextElement -> Handler TextElement)
                       :<|> ((AuthResult Token
                              -> DocumentID
                              -> TextElementID
                              -> Maybe Bool
                              -> CreateTextRevision
                              -> Handler (Rendered ConflictStatus))
                             :<|> ((AuthResult Token
                                    -> DocumentID
                                    -> TextElementID
                                    -> TextRevisionSelector
                                    -> Handler (Maybe (Rendered TextElementRevision)))
                                   :<|> ((AuthResult Token
                                          -> DocumentID
                                          -> TextElementID
                                          -> TextRevisionSelector
                                          -> Handler PDFBytes)
                                         :<|> ((AuthResult Token
                                                -> DocumentID
                                                -> Node TextElementID
                                                -> Handler (TreeRevisionWithMetaData TextElementID))
                                               :<|> ((AuthResult Token
                                                      -> DocumentID
                                                      -> TreeRevisionSelector
                                                      -> Handler
                                                           (Maybe
                                                              (TreeRevisionWithMetaData
                                                                 TextElement)))
                                                     :<|> ((AuthResult Token
                                                            -> DocumentID
                                                            -> TreeRevisionSelector
                                                            -> Handler
                                                                 (Maybe
                                                                    (TreeRevisionWithMetaData
                                                                       TextElementRevision)))
                                                           :<|> ((AuthResult Token
                                                                  -> DocumentID
                                                                  -> TreeRevisionSelector
                                                                  -> Handler PDFBytes)
                                                                 :<|> ((AuthResult Token
                                                                        -> DocumentID
                                                                        -> TreeRevisionSelector
                                                                        -> Handler ZipBytes)
                                                                       :<|> ((AuthResult Token
                                                                              -> DocumentID
                                                                              -> TextElementID
                                                                              -> Maybe UTCTime
                                                                              -> Maybe UTCTime
                                                                              -> Maybe GroupID
                                                                              -> Handler
                                                                                   TextRevisionHistory)
                                                                             :<|> ((AuthResult Token
                                                                                    -> DocumentID
                                                                                    -> Maybe UTCTime
                                                                                    -> Maybe GroupID
                                                                                    -> Handler
                                                                                         TreeRevisionHistory)
                                                                                   :<|> ((AuthResult
                                                                                            Token
                                                                                          -> DocumentID
                                                                                          -> Maybe
                                                                                               UTCTime
                                                                                          -> Maybe
                                                                                               GroupID
                                                                                          -> Handler
                                                                                               DocumentHistory)
                                                                                         :<|> ((AuthResult
                                                                                                  Token
                                                                                                -> DocumentID
                                                                                                -> TextElementID
                                                                                                -> CreateComment
                                                                                                -> Handler
                                                                                                     Comment)
                                                                                               :<|> ((AuthResult
                                                                                                        Token
                                                                                                      -> DocumentID
                                                                                                      -> TextElementID
                                                                                                      -> Handler
                                                                                                           Comments)
                                                                                                     :<|> ((AuthResult
                                                                                                              Token
                                                                                                            -> DocumentID
                                                                                                            -> TextElementID
                                                                                                            -> CommentID
                                                                                                            -> Handler
                                                                                                                 ())
                                                                                                           :<|> ((AuthResult
                                                                                                                    Token
                                                                                                                  -> DocumentID
                                                                                                                  -> TextElementID
                                                                                                                  -> CommentID
                                                                                                                  -> CreateReply
                                                                                                                  -> Handler
                                                                                                                       Message)
                                                                                                                 :<|> ((AuthResult
                                                                                                                          Token
                                                                                                                        -> DocumentID
                                                                                                                        -> RevisionSelector
                                                                                                                        -> Handler
                                                                                                                             (FullDocument
                                                                                                                                TextElementRevision))
                                                                                                                       :<|> ((AuthResult
                                                                                                                                Token
                                                                                                                              -> DocumentID
                                                                                                                              -> RevisionSelector
                                                                                                                              -> Handler
                                                                                                                                   PDFBytes)
                                                                                                                             :<|> ((AuthResult
                                                                                                                                      Token
                                                                                                                                    -> DocumentID
                                                                                                                                    -> RevisionSelector
                                                                                                                                    -> Handler
                                                                                                                                         ZipBytes)
                                                                                                                                   :<|> ((AuthResult
                                                                                                                                            Token
                                                                                                                                          -> DocumentID
                                                                                                                                          -> RevisionSelector
                                                                                                                                          -> Handler
                                                                                                                                               (Maybe
                                                                                                                                                  (TreeRevision
                                                                                                                                                     TextElement)))
                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                  Token
                                                                                                                                                -> DocumentID
                                                                                                                                                -> RevisionSelector
                                                                                                                                                -> TextElementID
                                                                                                                                                -> Handler
                                                                                                                                                     (Maybe
                                                                                                                                                        TextElementRevision))
                                                                                                                                               :<|> ((AuthResult
                                                                                                                                                        Token
                                                                                                                                                      -> DocumentID
                                                                                                                                                      -> TextElementID
                                                                                                                                                      -> Handler
                                                                                                                                                           (Maybe
                                                                                                                                                              (Rendered
                                                                                                                                                                 DraftRevision)))
                                                                                                                                                     :<|> ((AuthResult
                                                                                                                                                              Token
                                                                                                                                                            -> DocumentID
                                                                                                                                                            -> TextElementID
                                                                                                                                                            -> Handler
                                                                                                                                                                 (Rendered
                                                                                                                                                                    ConflictStatus))
                                                                                                                                                           :<|> ((AuthResult
                                                                                                                                                                    Token
                                                                                                                                                                  -> DocumentID
                                                                                                                                                                  -> TextElementID
                                                                                                                                                                  -> Handler
                                                                                                                                                                       ())
                                                                                                                                                                 :<|> ((AuthResult
                                                                                                                                                                          Token
                                                                                                                                                                        -> Text
                                                                                                                                                                        -> Handler
                                                                                                                                                                             DocByteString)
                                                                                                                                                                       :<|> (AuthResult
                                                                                                                                                                               Token
                                                                                                                                                                             -> Text
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  PDFByteString)))))))))))))))))))))))))))))
    :<|> (((AuthResult Token -> Text -> Handler DocByteString)
           :<|> (AuthResult Token -> Text -> Handler PDFByteString))
          :<|> (AuthResult Token
                -> Maybe UTCTime -> Maybe GroupID -> Handler Logs)))
-> ((AuthResult Token -> GroupID -> UserID -> Handler Role)
    :<|> ((AuthResult Token
           -> GroupID -> UserID -> Role -> Handler NoContent)
          :<|> ((AuthResult Token -> GroupID -> UserID -> Handler NoContent)
                :<|> ((AuthResult Token -> UserID -> Handler NoContent)
                      :<|> (AuthResult Token -> UserID -> Handler NoContent)))))
   :<|> (((AuthResult Token
           -> CreateDocument
           -> Handler (FullDocument (Rendered TextElementRevision)))
          :<|> ((AuthResult Token -> DocumentID -> Handler Document)
                :<|> ((AuthResult Token
                       -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                      :<|> ((AuthResult Token
                             -> DocumentID -> CreateTextElement -> Handler TextElement)
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TextElementID
                                   -> Maybe Bool
                                   -> CreateTextRevision
                                   -> Handler (Rendered ConflictStatus))
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TextElementID
                                         -> TextRevisionSelector
                                         -> Handler (Maybe (Rendered TextElementRevision)))
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TextElementID
                                               -> TextRevisionSelector
                                               -> Handler PDFBytes)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> Node TextElementID
                                                     -> Handler
                                                          (TreeRevisionWithMetaData TextElementID))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TreeRevisionSelector
                                                           -> Handler
                                                                (Maybe
                                                                   (TreeRevisionWithMetaData
                                                                      TextElement)))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TreeRevisionSelector
                                                                 -> Handler
                                                                      (Maybe
                                                                         (TreeRevisionWithMetaData
                                                                            TextElementRevision)))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TreeRevisionSelector
                                                                       -> Handler PDFBytes)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TreeRevisionSelector
                                                                             -> Handler ZipBytes)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TextElementID
                                                                                   -> Maybe UTCTime
                                                                                   -> Maybe UTCTime
                                                                                   -> Maybe GroupID
                                                                                   -> Handler
                                                                                        TextRevisionHistory)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> Maybe
                                                                                              UTCTime
                                                                                         -> Maybe
                                                                                              GroupID
                                                                                         -> Handler
                                                                                              TreeRevisionHistory)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> Maybe
                                                                                                    UTCTime
                                                                                               -> Maybe
                                                                                                    GroupID
                                                                                               -> Handler
                                                                                                    DocumentHistory)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TextElementID
                                                                                                     -> CreateComment
                                                                                                     -> Handler
                                                                                                          Comment)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> TextElementID
                                                                                                           -> Handler
                                                                                                                Comments)
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> TextElementID
                                                                                                                 -> CommentID
                                                                                                                 -> Handler
                                                                                                                      ())
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> TextElementID
                                                                                                                       -> CommentID
                                                                                                                       -> CreateReply
                                                                                                                       -> Handler
                                                                                                                            Message)
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> RevisionSelector
                                                                                                                             -> Handler
                                                                                                                                  (FullDocument
                                                                                                                                     TextElementRevision))
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> RevisionSelector
                                                                                                                                   -> Handler
                                                                                                                                        PDFBytes)
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> RevisionSelector
                                                                                                                                         -> Handler
                                                                                                                                              ZipBytes)
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> RevisionSelector
                                                                                                                                               -> Handler
                                                                                                                                                    (Maybe
                                                                                                                                                       (TreeRevision
                                                                                                                                                          TextElement)))
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> DocumentID
                                                                                                                                                     -> RevisionSelector
                                                                                                                                                     -> TextElementID
                                                                                                                                                     -> Handler
                                                                                                                                                          (Maybe
                                                                                                                                                             TextElementRevision))
                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                             Token
                                                                                                                                                           -> DocumentID
                                                                                                                                                           -> TextElementID
                                                                                                                                                           -> Handler
                                                                                                                                                                (Maybe
                                                                                                                                                                   (Rendered
                                                                                                                                                                      DraftRevision)))
                                                                                                                                                          :<|> ((AuthResult
                                                                                                                                                                   Token
                                                                                                                                                                 -> DocumentID
                                                                                                                                                                 -> TextElementID
                                                                                                                                                                 -> Handler
                                                                                                                                                                      (Rendered
                                                                                                                                                                         ConflictStatus))
                                                                                                                                                                :<|> ((AuthResult
                                                                                                                                                                         Token
                                                                                                                                                                       -> DocumentID
                                                                                                                                                                       -> TextElementID
                                                                                                                                                                       -> Handler
                                                                                                                                                                            ())
                                                                                                                                                                      :<|> ((AuthResult
                                                                                                                                                                               Token
                                                                                                                                                                             -> Text
                                                                                                                                                                             -> Handler
                                                                                                                                                                                  DocByteString)
                                                                                                                                                                            :<|> (AuthResult
                                                                                                                                                                                    Token
                                                                                                                                                                                  -> Text
                                                                                                                                                                                  -> Handler
                                                                                                                                                                                       PDFByteString)))))))))))))))))))))))))))))
         :<|> (((AuthResult Token -> Text -> Handler DocByteString)
                :<|> (AuthResult Token -> Text -> Handler PDFByteString))
               :<|> (AuthResult Token
                     -> Maybe UTCTime -> Maybe GroupID -> Handler Logs)))
forall a b. a -> b -> a :<|> b
:<|> (AuthResult Token
 -> CreateDocument
 -> Handler (FullDocument (Rendered TextElementRevision)))
:<|> ((AuthResult Token -> DocumentID -> Handler Document)
      :<|> ((AuthResult Token
             -> Maybe UserID -> Maybe GroupID -> Handler Documents)
            :<|> ((AuthResult Token
                   -> DocumentID -> CreateTextElement -> Handler TextElement)
                  :<|> ((AuthResult Token
                         -> DocumentID
                         -> TextElementID
                         -> Maybe Bool
                         -> CreateTextRevision
                         -> Handler (Rendered ConflictStatus))
                        :<|> ((AuthResult Token
                               -> DocumentID
                               -> TextElementID
                               -> TextRevisionSelector
                               -> Handler (Maybe (Rendered TextElementRevision)))
                              :<|> ((AuthResult Token
                                     -> DocumentID
                                     -> TextElementID
                                     -> TextRevisionSelector
                                     -> Handler PDFBytes)
                                    :<|> ((AuthResult Token
                                           -> DocumentID
                                           -> Node TextElementID
                                           -> Handler (TreeRevisionWithMetaData TextElementID))
                                          :<|> ((AuthResult Token
                                                 -> DocumentID
                                                 -> TreeRevisionSelector
                                                 -> Handler
                                                      (Maybe
                                                         (TreeRevisionWithMetaData TextElement)))
                                                :<|> ((AuthResult Token
                                                       -> DocumentID
                                                       -> TreeRevisionSelector
                                                       -> Handler
                                                            (Maybe
                                                               (TreeRevisionWithMetaData
                                                                  TextElementRevision)))
                                                      :<|> ((AuthResult Token
                                                             -> DocumentID
                                                             -> TreeRevisionSelector
                                                             -> Handler PDFBytes)
                                                            :<|> ((AuthResult Token
                                                                   -> DocumentID
                                                                   -> TreeRevisionSelector
                                                                   -> Handler ZipBytes)
                                                                  :<|> ((AuthResult Token
                                                                         -> DocumentID
                                                                         -> TextElementID
                                                                         -> Maybe UTCTime
                                                                         -> Maybe UTCTime
                                                                         -> Maybe GroupID
                                                                         -> Handler
                                                                              TextRevisionHistory)
                                                                        :<|> ((AuthResult Token
                                                                               -> DocumentID
                                                                               -> Maybe UTCTime
                                                                               -> Maybe GroupID
                                                                               -> Handler
                                                                                    TreeRevisionHistory)
                                                                              :<|> ((AuthResult
                                                                                       Token
                                                                                     -> DocumentID
                                                                                     -> Maybe
                                                                                          UTCTime
                                                                                     -> Maybe
                                                                                          GroupID
                                                                                     -> Handler
                                                                                          DocumentHistory)
                                                                                    :<|> ((AuthResult
                                                                                             Token
                                                                                           -> DocumentID
                                                                                           -> TextElementID
                                                                                           -> CreateComment
                                                                                           -> Handler
                                                                                                Comment)
                                                                                          :<|> ((AuthResult
                                                                                                   Token
                                                                                                 -> DocumentID
                                                                                                 -> TextElementID
                                                                                                 -> Handler
                                                                                                      Comments)
                                                                                                :<|> ((AuthResult
                                                                                                         Token
                                                                                                       -> DocumentID
                                                                                                       -> TextElementID
                                                                                                       -> CommentID
                                                                                                       -> Handler
                                                                                                            ())
                                                                                                      :<|> ((AuthResult
                                                                                                               Token
                                                                                                             -> DocumentID
                                                                                                             -> TextElementID
                                                                                                             -> CommentID
                                                                                                             -> CreateReply
                                                                                                             -> Handler
                                                                                                                  Message)
                                                                                                            :<|> ((AuthResult
                                                                                                                     Token
                                                                                                                   -> DocumentID
                                                                                                                   -> RevisionSelector
                                                                                                                   -> Handler
                                                                                                                        (FullDocument
                                                                                                                           TextElementRevision))
                                                                                                                  :<|> ((AuthResult
                                                                                                                           Token
                                                                                                                         -> DocumentID
                                                                                                                         -> RevisionSelector
                                                                                                                         -> Handler
                                                                                                                              PDFBytes)
                                                                                                                        :<|> ((AuthResult
                                                                                                                                 Token
                                                                                                                               -> DocumentID
                                                                                                                               -> RevisionSelector
                                                                                                                               -> Handler
                                                                                                                                    ZipBytes)
                                                                                                                              :<|> ((AuthResult
                                                                                                                                       Token
                                                                                                                                     -> DocumentID
                                                                                                                                     -> RevisionSelector
                                                                                                                                     -> Handler
                                                                                                                                          (Maybe
                                                                                                                                             (TreeRevision
                                                                                                                                                TextElement)))
                                                                                                                                    :<|> ((AuthResult
                                                                                                                                             Token
                                                                                                                                           -> DocumentID
                                                                                                                                           -> RevisionSelector
                                                                                                                                           -> TextElementID
                                                                                                                                           -> Handler
                                                                                                                                                (Maybe
                                                                                                                                                   TextElementRevision))
                                                                                                                                          :<|> ((AuthResult
                                                                                                                                                   Token
                                                                                                                                                 -> DocumentID
                                                                                                                                                 -> TextElementID
                                                                                                                                                 -> Handler
                                                                                                                                                      (Maybe
                                                                                                                                                         (Rendered
                                                                                                                                                            DraftRevision)))
                                                                                                                                                :<|> ((AuthResult
                                                                                                                                                         Token
                                                                                                                                                       -> DocumentID
                                                                                                                                                       -> TextElementID
                                                                                                                                                       -> Handler
                                                                                                                                                            (Rendered
                                                                                                                                                               ConflictStatus))
                                                                                                                                                      :<|> ((AuthResult
                                                                                                                                                               Token
                                                                                                                                                             -> DocumentID
                                                                                                                                                             -> TextElementID
                                                                                                                                                             -> Handler
                                                                                                                                                                  ())
                                                                                                                                                            :<|> ((AuthResult
                                                                                                                                                                     Token
                                                                                                                                                                   -> Text
                                                                                                                                                                   -> Handler
                                                                                                                                                                        DocByteString)
                                                                                                                                                                  :<|> (AuthResult
                                                                                                                                                                          Token
                                                                                                                                                                        -> Text
                                                                                                                                                                        -> Handler
                                                                                                                                                                             PDFByteString))))))))))))))))))))))))))))
Server DocsAPI
docsServer
                ((AuthResult Token
  -> CreateDocument
  -> Handler (FullDocument (Rendered TextElementRevision)))
 :<|> ((AuthResult Token -> DocumentID -> Handler Document)
       :<|> ((AuthResult Token
              -> Maybe UserID -> Maybe GroupID -> Handler Documents)
             :<|> ((AuthResult Token
                    -> DocumentID -> CreateTextElement -> Handler TextElement)
                   :<|> ((AuthResult Token
                          -> DocumentID
                          -> TextElementID
                          -> Maybe Bool
                          -> CreateTextRevision
                          -> Handler (Rendered ConflictStatus))
                         :<|> ((AuthResult Token
                                -> DocumentID
                                -> TextElementID
                                -> TextRevisionSelector
                                -> Handler (Maybe (Rendered TextElementRevision)))
                               :<|> ((AuthResult Token
                                      -> DocumentID
                                      -> TextElementID
                                      -> TextRevisionSelector
                                      -> Handler PDFBytes)
                                     :<|> ((AuthResult Token
                                            -> DocumentID
                                            -> Node TextElementID
                                            -> Handler (TreeRevisionWithMetaData TextElementID))
                                           :<|> ((AuthResult Token
                                                  -> DocumentID
                                                  -> TreeRevisionSelector
                                                  -> Handler
                                                       (Maybe
                                                          (TreeRevisionWithMetaData TextElement)))
                                                 :<|> ((AuthResult Token
                                                        -> DocumentID
                                                        -> TreeRevisionSelector
                                                        -> Handler
                                                             (Maybe
                                                                (TreeRevisionWithMetaData
                                                                   TextElementRevision)))
                                                       :<|> ((AuthResult Token
                                                              -> DocumentID
                                                              -> TreeRevisionSelector
                                                              -> Handler PDFBytes)
                                                             :<|> ((AuthResult Token
                                                                    -> DocumentID
                                                                    -> TreeRevisionSelector
                                                                    -> Handler ZipBytes)
                                                                   :<|> ((AuthResult Token
                                                                          -> DocumentID
                                                                          -> TextElementID
                                                                          -> Maybe UTCTime
                                                                          -> Maybe UTCTime
                                                                          -> Maybe GroupID
                                                                          -> Handler
                                                                               TextRevisionHistory)
                                                                         :<|> ((AuthResult Token
                                                                                -> DocumentID
                                                                                -> Maybe UTCTime
                                                                                -> Maybe GroupID
                                                                                -> Handler
                                                                                     TreeRevisionHistory)
                                                                               :<|> ((AuthResult
                                                                                        Token
                                                                                      -> DocumentID
                                                                                      -> Maybe
                                                                                           UTCTime
                                                                                      -> Maybe
                                                                                           GroupID
                                                                                      -> Handler
                                                                                           DocumentHistory)
                                                                                     :<|> ((AuthResult
                                                                                              Token
                                                                                            -> DocumentID
                                                                                            -> TextElementID
                                                                                            -> CreateComment
                                                                                            -> Handler
                                                                                                 Comment)
                                                                                           :<|> ((AuthResult
                                                                                                    Token
                                                                                                  -> DocumentID
                                                                                                  -> TextElementID
                                                                                                  -> Handler
                                                                                                       Comments)
                                                                                                 :<|> ((AuthResult
                                                                                                          Token
                                                                                                        -> DocumentID
                                                                                                        -> TextElementID
                                                                                                        -> CommentID
                                                                                                        -> Handler
                                                                                                             ())
                                                                                                       :<|> ((AuthResult
                                                                                                                Token
                                                                                                              -> DocumentID
                                                                                                              -> TextElementID
                                                                                                              -> CommentID
                                                                                                              -> CreateReply
                                                                                                              -> Handler
                                                                                                                   Message)
                                                                                                             :<|> ((AuthResult
                                                                                                                      Token
                                                                                                                    -> DocumentID
                                                                                                                    -> RevisionSelector
                                                                                                                    -> Handler
                                                                                                                         (FullDocument
                                                                                                                            TextElementRevision))
                                                                                                                   :<|> ((AuthResult
                                                                                                                            Token
                                                                                                                          -> DocumentID
                                                                                                                          -> RevisionSelector
                                                                                                                          -> Handler
                                                                                                                               PDFBytes)
                                                                                                                         :<|> ((AuthResult
                                                                                                                                  Token
                                                                                                                                -> DocumentID
                                                                                                                                -> RevisionSelector
                                                                                                                                -> Handler
                                                                                                                                     ZipBytes)
                                                                                                                               :<|> ((AuthResult
                                                                                                                                        Token
                                                                                                                                      -> DocumentID
                                                                                                                                      -> RevisionSelector
                                                                                                                                      -> Handler
                                                                                                                                           (Maybe
                                                                                                                                              (TreeRevision
                                                                                                                                                 TextElement)))
                                                                                                                                     :<|> ((AuthResult
                                                                                                                                              Token
                                                                                                                                            -> DocumentID
                                                                                                                                            -> RevisionSelector
                                                                                                                                            -> TextElementID
                                                                                                                                            -> Handler
                                                                                                                                                 (Maybe
                                                                                                                                                    TextElementRevision))
                                                                                                                                           :<|> ((AuthResult
                                                                                                                                                    Token
                                                                                                                                                  -> DocumentID
                                                                                                                                                  -> TextElementID
                                                                                                                                                  -> Handler
                                                                                                                                                       (Maybe
                                                                                                                                                          (Rendered
                                                                                                                                                             DraftRevision)))
                                                                                                                                                 :<|> ((AuthResult
                                                                                                                                                          Token
                                                                                                                                                        -> DocumentID
                                                                                                                                                        -> TextElementID
                                                                                                                                                        -> Handler
                                                                                                                                                             (Rendered
                                                                                                                                                                ConflictStatus))
                                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                                Token
                                                                                                                                                              -> DocumentID
                                                                                                                                                              -> TextElementID
                                                                                                                                                              -> Handler
                                                                                                                                                                   ())
                                                                                                                                                             :<|> ((AuthResult
                                                                                                                                                                      Token
                                                                                                                                                                    -> Text
                                                                                                                                                                    -> Handler
                                                                                                                                                                         DocByteString)
                                                                                                                                                                   :<|> (AuthResult
                                                                                                                                                                           Token
                                                                                                                                                                         -> Text
                                                                                                                                                                         -> Handler
                                                                                                                                                                              PDFByteString)))))))))))))))))))))))))))))
-> (((AuthResult Token -> Text -> Handler DocByteString)
     :<|> (AuthResult Token -> Text -> Handler PDFByteString))
    :<|> (AuthResult Token
          -> Maybe UTCTime -> Maybe GroupID -> Handler Logs))
-> ((AuthResult Token
     -> CreateDocument
     -> Handler (FullDocument (Rendered TextElementRevision)))
    :<|> ((AuthResult Token -> DocumentID -> Handler Document)
          :<|> ((AuthResult Token
                 -> Maybe UserID -> Maybe GroupID -> Handler Documents)
                :<|> ((AuthResult Token
                       -> DocumentID -> CreateTextElement -> Handler TextElement)
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> TextElementID
                             -> Maybe Bool
                             -> CreateTextRevision
                             -> Handler (Rendered ConflictStatus))
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TextElementID
                                   -> TextRevisionSelector
                                   -> Handler (Maybe (Rendered TextElementRevision)))
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TextElementID
                                         -> TextRevisionSelector
                                         -> Handler PDFBytes)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> Node TextElementID
                                               -> Handler (TreeRevisionWithMetaData TextElementID))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TreeRevisionSelector
                                                     -> Handler
                                                          (Maybe
                                                             (TreeRevisionWithMetaData
                                                                TextElement)))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TreeRevisionSelector
                                                           -> Handler
                                                                (Maybe
                                                                   (TreeRevisionWithMetaData
                                                                      TextElementRevision)))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TreeRevisionSelector
                                                                 -> Handler PDFBytes)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TreeRevisionSelector
                                                                       -> Handler ZipBytes)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TextElementID
                                                                             -> Maybe UTCTime
                                                                             -> Maybe UTCTime
                                                                             -> Maybe GroupID
                                                                             -> Handler
                                                                                  TextRevisionHistory)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> Maybe UTCTime
                                                                                   -> Maybe GroupID
                                                                                   -> Handler
                                                                                        TreeRevisionHistory)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> Maybe
                                                                                              UTCTime
                                                                                         -> Maybe
                                                                                              GroupID
                                                                                         -> Handler
                                                                                              DocumentHistory)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TextElementID
                                                                                               -> CreateComment
                                                                                               -> Handler
                                                                                                    Comment)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TextElementID
                                                                                                     -> Handler
                                                                                                          Comments)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> TextElementID
                                                                                                           -> CommentID
                                                                                                           -> Handler
                                                                                                                ())
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> TextElementID
                                                                                                                 -> CommentID
                                                                                                                 -> CreateReply
                                                                                                                 -> Handler
                                                                                                                      Message)
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> RevisionSelector
                                                                                                                       -> Handler
                                                                                                                            (FullDocument
                                                                                                                               TextElementRevision))
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> RevisionSelector
                                                                                                                             -> Handler
                                                                                                                                  PDFBytes)
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> RevisionSelector
                                                                                                                                   -> Handler
                                                                                                                                        ZipBytes)
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> RevisionSelector
                                                                                                                                         -> Handler
                                                                                                                                              (Maybe
                                                                                                                                                 (TreeRevision
                                                                                                                                                    TextElement)))
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> RevisionSelector
                                                                                                                                               -> TextElementID
                                                                                                                                               -> Handler
                                                                                                                                                    (Maybe
                                                                                                                                                       TextElementRevision))
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> DocumentID
                                                                                                                                                     -> TextElementID
                                                                                                                                                     -> Handler
                                                                                                                                                          (Maybe
                                                                                                                                                             (Rendered
                                                                                                                                                                DraftRevision)))
                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                             Token
                                                                                                                                                           -> DocumentID
                                                                                                                                                           -> TextElementID
                                                                                                                                                           -> Handler
                                                                                                                                                                (Rendered
                                                                                                                                                                   ConflictStatus))
                                                                                                                                                          :<|> ((AuthResult
                                                                                                                                                                   Token
                                                                                                                                                                 -> DocumentID
                                                                                                                                                                 -> TextElementID
                                                                                                                                                                 -> Handler
                                                                                                                                                                      ())
                                                                                                                                                                :<|> ((AuthResult
                                                                                                                                                                         Token
                                                                                                                                                                       -> Text
                                                                                                                                                                       -> Handler
                                                                                                                                                                            DocByteString)
                                                                                                                                                                      :<|> (AuthResult
                                                                                                                                                                              Token
                                                                                                                                                                            -> Text
                                                                                                                                                                            -> Handler
                                                                                                                                                                                 PDFByteString)))))))))))))))))))))))))))))
   :<|> (((AuthResult Token -> Text -> Handler DocByteString)
          :<|> (AuthResult Token -> Text -> Handler PDFByteString))
         :<|> (AuthResult Token
               -> Maybe UTCTime -> Maybe GroupID -> Handler Logs))
forall a b. a -> b -> a :<|> b
:<|> (AuthResult Token -> Text -> Handler DocByteString)
:<|> (AuthResult Token -> Text -> Handler PDFByteString)
Server RenderAPI
renderServer
                ((AuthResult Token -> Text -> Handler DocByteString)
 :<|> (AuthResult Token -> Text -> Handler PDFByteString))
-> (AuthResult Token
    -> Maybe UTCTime -> Maybe GroupID -> Handler Logs)
-> ((AuthResult Token -> Text -> Handler DocByteString)
    :<|> (AuthResult Token -> Text -> Handler PDFByteString))
   :<|> (AuthResult Token
         -> Maybe UTCTime -> Maybe GroupID -> Handler Logs)
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token -> Maybe UTCTime -> Maybe GroupID -> Handler Logs
logsHandler
             )

documentedAPI :: Proxy DocumentedAPI
documentedAPI :: Proxy DocumentedAPI
documentedAPI = Proxy DocumentedAPI
forall {k} (t :: k). Proxy t
Proxy

-- | Used to construct the app with the given cookie and JWT settings.
app :: CookieSettings -> JWTSettings -> Application
app :: CookieSettings -> JWTSettings -> Application
app CookieSettings
cookieSett JWTSettings
jwtSett =
    Proxy DocumentedAPI
-> Context '[CookieSettings, JWTSettings]
-> Server DocumentedAPI
-> Application
forall {k} (api :: k) (context :: [*]).
(HasServer api context, ServerContext context) =>
Proxy api -> Context context -> Server api -> Application
serveWithContext
        Proxy DocumentedAPI
documentedAPI
        (CookieSettings
cookieSett CookieSettings
-> Context '[JWTSettings] -> Context '[CookieSettings, JWTSettings]
forall x (xs :: [*]). x -> Context xs -> Context (x : xs)
:. JWTSettings
jwtSett JWTSettings -> Context '[] -> Context '[JWTSettings]
forall x (xs :: [*]). x -> Context xs -> Context (x : xs)
:. Context '[]
EmptyContext)
        (CookieSettings -> JWTSettings -> Server DocumentedAPI
server CookieSettings
cookieSett JWTSettings
jwtSett)

-- | The JWT settings used for the app
jwtSettings :: JWK -> JWTSettings
jwtSettings :: JWK -> JWTSettings
jwtSettings = JWK -> JWTSettings
defaultJWTSettings

-- | The cookie settings used for the app
cookieSettings :: CookieSettings
cookieSettings :: CookieSettings
cookieSettings = CookieSettings
defaultCookieSettings

-- | Runs the server
runServer :: IO ()
runServer :: IO ()
runServer = do
    let port :: Port
port = Port
80
    JWK
jwtSecretKey <- IO JWK
generateKey
    let jwtSett :: JWTSettings
jwtSett = JWK -> JWTSettings
jwtSettings JWK
jwtSecretKey
    Port -> Application -> IO ()
run Port
port (CookieSettings -> JWTSettings -> Application
app CookieSettings
cookieSettings JWTSettings
jwtSett)