{-# LANGUAGE OverloadedLabels #-}

module WikiMusic.SSR.Servant.ApiSetup (mkApp) where

import Data.Text qualified as T
import Data.Time
import Network.HTTP.Client (newManager)
import Network.HTTP.Client.TLS (tlsManagerSettings)
import Network.Wai
import Network.Wai.Middleware.Cors
import Optics
import Relude
import Servant
import Servant.Client
import WikiMusic.SSR.Backend.Rest ()
import WikiMusic.SSR.Model.Config
import WikiMusic.SSR.Model.Env
import WikiMusic.SSR.Servant.ApiSpec
import WikiMusic.SSR.Servant.ArtistRoutes
import WikiMusic.SSR.Servant.GenreRoutes
import WikiMusic.SSR.Servant.LoginRoutes
import WikiMusic.SSR.Servant.PreferenceRoutes
import WikiMusic.SSR.Servant.SongRoutes
import WikiMusic.SSR.View.Html ()

newClientEnv :: (MonadIO m) => m ClientEnv
newClientEnv :: forall (m :: * -> *). MonadIO m => m ClientEnv
newClientEnv = do
  Manager
manager <- IO Manager -> m Manager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Manager -> m Manager) -> IO Manager -> m Manager
forall a b. (a -> b) -> a -> b
$ ManagerSettings -> IO Manager
newManager ManagerSettings
tlsManagerSettings
  ClientEnv -> m ClientEnv
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ClientEnv -> m ClientEnv) -> ClientEnv -> m ClientEnv
forall a b. (a -> b) -> a -> b
$ Manager -> Maybe (TVar CookieJar) -> ClientEnv
clientEnv Manager
manager Maybe (TVar CookieJar)
forall a. Maybe a
Nothing
  where
    baseUrl' :: BaseUrl
baseUrl' =
      BaseUrl
        { baseUrlScheme :: Scheme
baseUrlScheme = Scheme
Https,
          baseUrlHost :: String
baseUrlHost = String
"api.wikimusic.jointhefreeworld.org",
          baseUrlPort :: Int
baseUrlPort = Int
443,
          baseUrlPath :: String
baseUrlPath = String
""
        }
    clientEnv :: Manager -> Maybe (TVar CookieJar) -> ClientEnv
clientEnv Manager
manager Maybe (TVar CookieJar)
cookieJar =
      ClientEnv
        { manager :: Manager
manager = Manager
manager,
          baseUrl :: BaseUrl
baseUrl = BaseUrl
baseUrl',
          cookieJar :: Maybe (TVar CookieJar)
cookieJar = Maybe (TVar CookieJar)
cookieJar,
          makeClientRequest :: BaseUrl -> Request -> IO Request
makeClientRequest = BaseUrl -> Request -> IO Request
defaultMakeClientRequest
        }

mkApp :: AppConfig -> IO Application
mkApp :: AppConfig -> IO Application
mkApp AppConfig
cfg = do
  let apiCfg :: Context NoIx
apiCfg = Context NoIx
EmptyContext
  ZonedTime
now <- IO ZonedTime
getZonedTime
  Origin
mainCss <- IO Origin -> IO Origin
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO Origin
forall (m :: * -> *). MonadIO m => String -> m Origin
readFileBS String
"resources/css/main.css")
  Origin
lightCss <- IO Origin -> IO Origin
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO Origin
forall (m :: * -> *). MonadIO m => String -> m Origin
readFileBS String
"resources/css/light.css")
  Origin
darkCss <- IO Origin -> IO Origin
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO Origin
forall (m :: * -> *). MonadIO m => String -> m Origin
readFileBS String
"resources/css/dark.css")
  Origin
greenPaletteCss <- IO Origin -> IO Origin
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO Origin
forall (m :: * -> *). MonadIO m => String -> m Origin
readFileBS String
"resources/css/palettes/green.css")
  Origin
mauvePaletteCss <- IO Origin -> IO Origin
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO Origin
forall (m :: * -> *). MonadIO m => String -> m Origin
readFileBS String
"resources/css/palettes/mauve.css")
  ClientEnv
clientEnv <- IO ClientEnv
forall (m :: * -> *). MonadIO m => m ClientEnv
newClientEnv
  let env :: Env
env =
        Env
          { $sel:cfg:Env :: AppConfig
cfg = AppConfig
cfg,
            $sel:processStartedAt:Env :: ZonedTime
processStartedAt = ZonedTime
now,
            $sel:reportedVersion:Env :: Text
reportedVersion = AppConfig
cfg AppConfig -> Optic' A_Lens NoIx AppConfig Text -> Text
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic A_Lens NoIx AppConfig AppConfig DevConfig DevConfig
#dev Optic A_Lens NoIx AppConfig AppConfig DevConfig DevConfig
-> Optic An_Iso NoIx DevConfig DevConfig Text Text
-> Optic' A_Lens NoIx AppConfig Text
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic An_Iso NoIx DevConfig DevConfig Text Text
#reportedVersion,
            $sel:mainCss:Env :: Text
mainCss = Origin -> Text
prepareCSS Origin
mainCss,
            $sel:darkCss:Env :: Text
darkCss = Origin -> Text
prepareCSS Origin
darkCss,
            $sel:lightCss:Env :: Text
lightCss = Origin -> Text
prepareCSS Origin
lightCss,
            $sel:clientEnv:Env :: ClientEnv
clientEnv = ClientEnv
clientEnv,
            $sel:palettes:Env :: PalettesCss
palettes =
              PalettesCss
                { $sel:green:PalettesCss :: Text
green = Origin -> Text
prepareCSS Origin
greenPaletteCss,
                  $sel:mauve:PalettesCss :: Text
mauve = Origin -> Text
prepareCSS Origin
mauvePaletteCss
                }
          }
  Application -> IO Application
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    (Application -> IO Application)
-> (Application -> Application) -> Application -> IO Application
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CorsConfig -> Application -> Application
myCors (AppConfig
cfg AppConfig -> Optic' A_Lens NoIx AppConfig CorsConfig -> CorsConfig
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx AppConfig CorsConfig
#cors)
    (Application -> IO Application) -> Application -> IO Application
forall a b. (a -> b) -> a -> b
$ Proxy WikiMusicSSRServant
-> Context NoIx -> Server WikiMusicSSRServant -> Application
forall api (context :: IxList).
(HasServer api context, ServerContext context) =>
Proxy api -> Context context -> Server api -> Application
serveWithContext Proxy WikiMusicSSRServant
wikimusicSSRServant Context NoIx
apiCfg (Env -> Server WikiMusicSSRServant
server Env
env)
  where
    prepareCSS :: Origin -> Text
prepareCSS = (Char -> Bool) -> Text -> Text
T.filter (\Char
x -> Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\n' Bool -> Bool -> Bool
&& Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\t') (Text -> Text) -> (Origin -> Text) -> Origin -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Origin -> Text
forall a b. ConvertUtf8 a b => b -> a
decodeUtf8

server :: Env -> Server WikiMusicSSRServant
server :: Env -> Server WikiMusicSSRServant
server Env
env =
  Handler NoContent
forall a. Handler a
fallbackRoute
    Handler NoContent
-> ((Maybe Text
     -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
    :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
          :<|> ((Maybe Text -> Handler (MarkupM ()))
                :<|> ((Maybe Text
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> ((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> ((Maybe Text
                                   -> Maybe Text
                                   -> UUID
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                  :<|> ((Maybe Text
                                         -> Maybe Text
                                         -> Maybe Int
                                         -> Maybe Int
                                         -> Handler (MarkupM ()))
                                        :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                              :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                    :<|> ((Maybe Text
                                                           -> Maybe Text
                                                           -> Maybe Int
                                                           -> Maybe Int
                                                           -> Handler (MarkupM ()))
                                                          :<|> ((Maybe Text
                                                                 -> UUID -> Handler (MarkupM ()))
                                                                :<|> ((Maybe Text
                                                                       -> Handler (MarkupM ()))
                                                                      :<|> ((Maybe Text
                                                                             -> MultipartData Mem
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Set-Cookie"
                                                                                        Text
                                                                                        : Header
                                                                                            "Location"
                                                                                            Text
                                                                                        : NoIx)
                                                                                     NoContent))
                                                                            :<|> ((Maybe Text
                                                                                   -> MultipartData
                                                                                        Mem
                                                                                   -> Handler
                                                                                        (Headers
                                                                                           (Header
                                                                                              "Set-Cookie"
                                                                                              Text
                                                                                              : Header
                                                                                                  "Location"
                                                                                                  Text
                                                                                              : NoIx)
                                                                                           NoContent))
                                                                                  :<|> ((Maybe Text
                                                                                         -> MultipartData
                                                                                              Mem
                                                                                         -> Handler
                                                                                              (Headers
                                                                                                 (Header
                                                                                                    "Set-Cookie"
                                                                                                    Text
                                                                                                    : Header
                                                                                                        "Location"
                                                                                                        Text
                                                                                                    : NoIx)
                                                                                                 NoContent))
                                                                                        :<|> ((Maybe
                                                                                                 Text
                                                                                               -> MultipartData
                                                                                                    Mem
                                                                                               -> Handler
                                                                                                    (Headers
                                                                                                       (Header
                                                                                                          "Set-Cookie"
                                                                                                          Text
                                                                                                          : Header
                                                                                                              "Location"
                                                                                                              Text
                                                                                                          : NoIx)
                                                                                                       NoContent))
                                                                                              :<|> ((Maybe
                                                                                                       Text
                                                                                                     -> MultipartData
                                                                                                          Mem
                                                                                                     -> Handler
                                                                                                          (Headers
                                                                                                             (Header
                                                                                                                "Set-Cookie"
                                                                                                                Text
                                                                                                                : Header
                                                                                                                    "Location"
                                                                                                                    Text
                                                                                                                : NoIx)
                                                                                                             NoContent))
                                                                                                    :<|> ((Maybe
                                                                                                             Text
                                                                                                           -> MultipartData
                                                                                                                Mem
                                                                                                           -> Handler
                                                                                                                (Headers
                                                                                                                   (Header
                                                                                                                      "Set-Cookie"
                                                                                                                      Text
                                                                                                                      : Header
                                                                                                                          "Location"
                                                                                                                          Text
                                                                                                                      : NoIx)
                                                                                                                   NoContent))
                                                                                                          :<|> ((Maybe
                                                                                                                   Text
                                                                                                                 -> MultipartData
                                                                                                                      Mem
                                                                                                                 -> Handler
                                                                                                                      (Headers
                                                                                                                         (Header
                                                                                                                            "Set-Cookie"
                                                                                                                            Text
                                                                                                                            : Header
                                                                                                                                "Location"
                                                                                                                                Text
                                                                                                                            : NoIx)
                                                                                                                         NoContent))
                                                                                                                :<|> ((Maybe
                                                                                                                         Text
                                                                                                                       -> Handler
                                                                                                                            (MarkupM
                                                                                                                               ()))
                                                                                                                      :<|> (MultipartData
                                                                                                                              Mem
                                                                                                                            -> Handler
                                                                                                                                 (Headers
                                                                                                                                    (Header
                                                                                                                                       "Set-Cookie"
                                                                                                                                       Text
                                                                                                                                       : Header
                                                                                                                                           "Location"
                                                                                                                                           Text
                                                                                                                                       : NoIx)
                                                                                                                                    NoContent))))))))))))))))))))))
-> Handler NoContent
   :<|> ((Maybe Text
          -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
         :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
               :<|> ((Maybe Text -> Handler (MarkupM ()))
                     :<|> ((Maybe Text
                            -> MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                           :<|> ((Maybe Text
                                  -> Maybe Text
                                  -> UUID
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                 :<|> ((Maybe Text
                                        -> Maybe Text
                                        -> UUID
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))
                                       :<|> ((Maybe Text
                                              -> Maybe Text
                                              -> Maybe Int
                                              -> Maybe Int
                                              -> Handler (MarkupM ()))
                                             :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                                   :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                         :<|> ((Maybe Text
                                                                -> Maybe Text
                                                                -> Maybe Int
                                                                -> Maybe Int
                                                                -> Handler (MarkupM ()))
                                                               :<|> ((Maybe Text
                                                                      -> UUID
                                                                      -> Handler (MarkupM ()))
                                                                     :<|> ((Maybe Text
                                                                            -> Handler (MarkupM ()))
                                                                           :<|> ((Maybe Text
                                                                                  -> MultipartData
                                                                                       Mem
                                                                                  -> Handler
                                                                                       (Headers
                                                                                          (Header
                                                                                             "Set-Cookie"
                                                                                             Text
                                                                                             : Header
                                                                                                 "Location"
                                                                                                 Text
                                                                                             : NoIx)
                                                                                          NoContent))
                                                                                 :<|> ((Maybe Text
                                                                                        -> MultipartData
                                                                                             Mem
                                                                                        -> Handler
                                                                                             (Headers
                                                                                                (Header
                                                                                                   "Set-Cookie"
                                                                                                   Text
                                                                                                   : Header
                                                                                                       "Location"
                                                                                                       Text
                                                                                                   : NoIx)
                                                                                                NoContent))
                                                                                       :<|> ((Maybe
                                                                                                Text
                                                                                              -> MultipartData
                                                                                                   Mem
                                                                                              -> Handler
                                                                                                   (Headers
                                                                                                      (Header
                                                                                                         "Set-Cookie"
                                                                                                         Text
                                                                                                         : Header
                                                                                                             "Location"
                                                                                                             Text
                                                                                                         : NoIx)
                                                                                                      NoContent))
                                                                                             :<|> ((Maybe
                                                                                                      Text
                                                                                                    -> MultipartData
                                                                                                         Mem
                                                                                                    -> Handler
                                                                                                         (Headers
                                                                                                            (Header
                                                                                                               "Set-Cookie"
                                                                                                               Text
                                                                                                               : Header
                                                                                                                   "Location"
                                                                                                                   Text
                                                                                                               : NoIx)
                                                                                                            NoContent))
                                                                                                   :<|> ((Maybe
                                                                                                            Text
                                                                                                          -> MultipartData
                                                                                                               Mem
                                                                                                          -> Handler
                                                                                                               (Headers
                                                                                                                  (Header
                                                                                                                     "Set-Cookie"
                                                                                                                     Text
                                                                                                                     : Header
                                                                                                                         "Location"
                                                                                                                         Text
                                                                                                                     : NoIx)
                                                                                                                  NoContent))
                                                                                                         :<|> ((Maybe
                                                                                                                  Text
                                                                                                                -> MultipartData
                                                                                                                     Mem
                                                                                                                -> Handler
                                                                                                                     (Headers
                                                                                                                        (Header
                                                                                                                           "Set-Cookie"
                                                                                                                           Text
                                                                                                                           : Header
                                                                                                                               "Location"
                                                                                                                               Text
                                                                                                                           : NoIx)
                                                                                                                        NoContent))
                                                                                                               :<|> ((Maybe
                                                                                                                        Text
                                                                                                                      -> MultipartData
                                                                                                                           Mem
                                                                                                                      -> Handler
                                                                                                                           (Headers
                                                                                                                              (Header
                                                                                                                                 "Set-Cookie"
                                                                                                                                 Text
                                                                                                                                 : Header
                                                                                                                                     "Location"
                                                                                                                                     Text
                                                                                                                                 : NoIx)
                                                                                                                              NoContent))
                                                                                                                     :<|> ((Maybe
                                                                                                                              Text
                                                                                                                            -> Handler
                                                                                                                                 (MarkupM
                                                                                                                                    ()))
                                                                                                                           :<|> (MultipartData
                                                                                                                                   Mem
                                                                                                                                 -> Handler
                                                                                                                                      (Headers
                                                                                                                                         (Header
                                                                                                                                            "Set-Cookie"
                                                                                                                                            Text
                                                                                                                                            : Header
                                                                                                                                                "Location"
                                                                                                                                                Text
                                                                                                                                            : NoIx)
                                                                                                                                         NoContent))))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> m (MarkupM ())
artistsRoute Env
env
    (Maybe Text
 -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
-> ((Maybe Text -> UUID -> Handler (MarkupM ()))
    :<|> ((Maybe Text -> Handler (MarkupM ()))
          :<|> ((Maybe Text
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> ((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> ((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> ((Maybe Text
                                   -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                                  :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                        :<|> ((Maybe Text -> Handler (MarkupM ()))
                                              :<|> ((Maybe Text
                                                     -> Maybe Text
                                                     -> Maybe Int
                                                     -> Maybe Int
                                                     -> Handler (MarkupM ()))
                                                    :<|> ((Maybe Text
                                                           -> UUID -> Handler (MarkupM ()))
                                                          :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                                :<|> ((Maybe Text
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Set-Cookie" Text
                                                                                  : Header
                                                                                      "Location"
                                                                                      Text
                                                                                  : NoIx)
                                                                               NoContent))
                                                                      :<|> ((Maybe Text
                                                                             -> MultipartData Mem
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Set-Cookie"
                                                                                        Text
                                                                                        : Header
                                                                                            "Location"
                                                                                            Text
                                                                                        : NoIx)
                                                                                     NoContent))
                                                                            :<|> ((Maybe Text
                                                                                   -> MultipartData
                                                                                        Mem
                                                                                   -> Handler
                                                                                        (Headers
                                                                                           (Header
                                                                                              "Set-Cookie"
                                                                                              Text
                                                                                              : Header
                                                                                                  "Location"
                                                                                                  Text
                                                                                              : NoIx)
                                                                                           NoContent))
                                                                                  :<|> ((Maybe Text
                                                                                         -> MultipartData
                                                                                              Mem
                                                                                         -> Handler
                                                                                              (Headers
                                                                                                 (Header
                                                                                                    "Set-Cookie"
                                                                                                    Text
                                                                                                    : Header
                                                                                                        "Location"
                                                                                                        Text
                                                                                                    : NoIx)
                                                                                                 NoContent))
                                                                                        :<|> ((Maybe
                                                                                                 Text
                                                                                               -> MultipartData
                                                                                                    Mem
                                                                                               -> Handler
                                                                                                    (Headers
                                                                                                       (Header
                                                                                                          "Set-Cookie"
                                                                                                          Text
                                                                                                          : Header
                                                                                                              "Location"
                                                                                                              Text
                                                                                                          : NoIx)
                                                                                                       NoContent))
                                                                                              :<|> ((Maybe
                                                                                                       Text
                                                                                                     -> MultipartData
                                                                                                          Mem
                                                                                                     -> Handler
                                                                                                          (Headers
                                                                                                             (Header
                                                                                                                "Set-Cookie"
                                                                                                                Text
                                                                                                                : Header
                                                                                                                    "Location"
                                                                                                                    Text
                                                                                                                : NoIx)
                                                                                                             NoContent))
                                                                                                    :<|> ((Maybe
                                                                                                             Text
                                                                                                           -> MultipartData
                                                                                                                Mem
                                                                                                           -> Handler
                                                                                                                (Headers
                                                                                                                   (Header
                                                                                                                      "Set-Cookie"
                                                                                                                      Text
                                                                                                                      : Header
                                                                                                                          "Location"
                                                                                                                          Text
                                                                                                                      : NoIx)
                                                                                                                   NoContent))
                                                                                                          :<|> ((Maybe
                                                                                                                   Text
                                                                                                                 -> Handler
                                                                                                                      (MarkupM
                                                                                                                         ()))
                                                                                                                :<|> (MultipartData
                                                                                                                        Mem
                                                                                                                      -> Handler
                                                                                                                           (Headers
                                                                                                                              (Header
                                                                                                                                 "Set-Cookie"
                                                                                                                                 Text
                                                                                                                                 : Header
                                                                                                                                     "Location"
                                                                                                                                     Text
                                                                                                                                 : NoIx)
                                                                                                                              NoContent)))))))))))))))))))))
-> (Maybe Text
    -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
   :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
         :<|> ((Maybe Text -> Handler (MarkupM ()))
               :<|> ((Maybe Text
                      -> MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                     :<|> ((Maybe Text
                            -> Maybe Text
                            -> UUID
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                           :<|> ((Maybe Text
                                  -> Maybe Text
                                  -> UUID
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                 :<|> ((Maybe Text
                                        -> Maybe Text
                                        -> Maybe Int
                                        -> Maybe Int
                                        -> Handler (MarkupM ()))
                                       :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                             :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                   :<|> ((Maybe Text
                                                          -> Maybe Text
                                                          -> Maybe Int
                                                          -> Maybe Int
                                                          -> Handler (MarkupM ()))
                                                         :<|> ((Maybe Text
                                                                -> UUID -> Handler (MarkupM ()))
                                                               :<|> ((Maybe Text
                                                                      -> Handler (MarkupM ()))
                                                                     :<|> ((Maybe Text
                                                                            -> MultipartData Mem
                                                                            -> Handler
                                                                                 (Headers
                                                                                    (Header
                                                                                       "Set-Cookie"
                                                                                       Text
                                                                                       : Header
                                                                                           "Location"
                                                                                           Text
                                                                                       : NoIx)
                                                                                    NoContent))
                                                                           :<|> ((Maybe Text
                                                                                  -> MultipartData
                                                                                       Mem
                                                                                  -> Handler
                                                                                       (Headers
                                                                                          (Header
                                                                                             "Set-Cookie"
                                                                                             Text
                                                                                             : Header
                                                                                                 "Location"
                                                                                                 Text
                                                                                             : NoIx)
                                                                                          NoContent))
                                                                                 :<|> ((Maybe Text
                                                                                        -> MultipartData
                                                                                             Mem
                                                                                        -> Handler
                                                                                             (Headers
                                                                                                (Header
                                                                                                   "Set-Cookie"
                                                                                                   Text
                                                                                                   : Header
                                                                                                       "Location"
                                                                                                       Text
                                                                                                   : NoIx)
                                                                                                NoContent))
                                                                                       :<|> ((Maybe
                                                                                                Text
                                                                                              -> MultipartData
                                                                                                   Mem
                                                                                              -> Handler
                                                                                                   (Headers
                                                                                                      (Header
                                                                                                         "Set-Cookie"
                                                                                                         Text
                                                                                                         : Header
                                                                                                             "Location"
                                                                                                             Text
                                                                                                         : NoIx)
                                                                                                      NoContent))
                                                                                             :<|> ((Maybe
                                                                                                      Text
                                                                                                    -> MultipartData
                                                                                                         Mem
                                                                                                    -> Handler
                                                                                                         (Headers
                                                                                                            (Header
                                                                                                               "Set-Cookie"
                                                                                                               Text
                                                                                                               : Header
                                                                                                                   "Location"
                                                                                                                   Text
                                                                                                               : NoIx)
                                                                                                            NoContent))
                                                                                                   :<|> ((Maybe
                                                                                                            Text
                                                                                                          -> MultipartData
                                                                                                               Mem
                                                                                                          -> Handler
                                                                                                               (Headers
                                                                                                                  (Header
                                                                                                                     "Set-Cookie"
                                                                                                                     Text
                                                                                                                     : Header
                                                                                                                         "Location"
                                                                                                                         Text
                                                                                                                     : NoIx)
                                                                                                                  NoContent))
                                                                                                         :<|> ((Maybe
                                                                                                                  Text
                                                                                                                -> MultipartData
                                                                                                                     Mem
                                                                                                                -> Handler
                                                                                                                     (Headers
                                                                                                                        (Header
                                                                                                                           "Set-Cookie"
                                                                                                                           Text
                                                                                                                           : Header
                                                                                                                               "Location"
                                                                                                                               Text
                                                                                                                           : NoIx)
                                                                                                                        NoContent))
                                                                                                               :<|> ((Maybe
                                                                                                                        Text
                                                                                                                      -> Handler
                                                                                                                           (MarkupM
                                                                                                                              ()))
                                                                                                                     :<|> (MultipartData
                                                                                                                             Mem
                                                                                                                           -> Handler
                                                                                                                                (Headers
                                                                                                                                   (Header
                                                                                                                                      "Set-Cookie"
                                                                                                                                      Text
                                                                                                                                      : Header
                                                                                                                                          "Location"
                                                                                                                                          Text
                                                                                                                                      : NoIx)
                                                                                                                                   NoContent)))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> UUID -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> UUID -> m (MarkupM ())
artistRoute Env
env
    (Maybe Text -> UUID -> Handler (MarkupM ()))
-> ((Maybe Text -> Handler (MarkupM ()))
    :<|> ((Maybe Text
           -> MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> ((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> ((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> ((Maybe Text
                             -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                            :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                  :<|> ((Maybe Text -> Handler (MarkupM ()))
                                        :<|> ((Maybe Text
                                               -> Maybe Text
                                               -> Maybe Int
                                               -> Maybe Int
                                               -> Handler (MarkupM ()))
                                              :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                                    :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                          :<|> ((Maybe Text
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Set-Cookie" Text
                                                                            : Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))
                                                                :<|> ((Maybe Text
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Set-Cookie" Text
                                                                                  : Header
                                                                                      "Location"
                                                                                      Text
                                                                                  : NoIx)
                                                                               NoContent))
                                                                      :<|> ((Maybe Text
                                                                             -> MultipartData Mem
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Set-Cookie"
                                                                                        Text
                                                                                        : Header
                                                                                            "Location"
                                                                                            Text
                                                                                        : NoIx)
                                                                                     NoContent))
                                                                            :<|> ((Maybe Text
                                                                                   -> MultipartData
                                                                                        Mem
                                                                                   -> Handler
                                                                                        (Headers
                                                                                           (Header
                                                                                              "Set-Cookie"
                                                                                              Text
                                                                                              : Header
                                                                                                  "Location"
                                                                                                  Text
                                                                                              : NoIx)
                                                                                           NoContent))
                                                                                  :<|> ((Maybe Text
                                                                                         -> MultipartData
                                                                                              Mem
                                                                                         -> Handler
                                                                                              (Headers
                                                                                                 (Header
                                                                                                    "Set-Cookie"
                                                                                                    Text
                                                                                                    : Header
                                                                                                        "Location"
                                                                                                        Text
                                                                                                    : NoIx)
                                                                                                 NoContent))
                                                                                        :<|> ((Maybe
                                                                                                 Text
                                                                                               -> MultipartData
                                                                                                    Mem
                                                                                               -> Handler
                                                                                                    (Headers
                                                                                                       (Header
                                                                                                          "Set-Cookie"
                                                                                                          Text
                                                                                                          : Header
                                                                                                              "Location"
                                                                                                              Text
                                                                                                          : NoIx)
                                                                                                       NoContent))
                                                                                              :<|> ((Maybe
                                                                                                       Text
                                                                                                     -> MultipartData
                                                                                                          Mem
                                                                                                     -> Handler
                                                                                                          (Headers
                                                                                                             (Header
                                                                                                                "Set-Cookie"
                                                                                                                Text
                                                                                                                : Header
                                                                                                                    "Location"
                                                                                                                    Text
                                                                                                                : NoIx)
                                                                                                             NoContent))
                                                                                                    :<|> ((Maybe
                                                                                                             Text
                                                                                                           -> Handler
                                                                                                                (MarkupM
                                                                                                                   ()))
                                                                                                          :<|> (MultipartData
                                                                                                                  Mem
                                                                                                                -> Handler
                                                                                                                     (Headers
                                                                                                                        (Header
                                                                                                                           "Set-Cookie"
                                                                                                                           Text
                                                                                                                           : Header
                                                                                                                               "Location"
                                                                                                                               Text
                                                                                                                           : NoIx)
                                                                                                                        NoContent))))))))))))))))))))
-> (Maybe Text -> UUID -> Handler (MarkupM ()))
   :<|> ((Maybe Text -> Handler (MarkupM ()))
         :<|> ((Maybe Text
                -> MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> ((Maybe Text
                      -> Maybe Text
                      -> UUID
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                     :<|> ((Maybe Text
                            -> Maybe Text
                            -> UUID
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                           :<|> ((Maybe Text
                                  -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                                 :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                       :<|> ((Maybe Text -> Handler (MarkupM ()))
                                             :<|> ((Maybe Text
                                                    -> Maybe Text
                                                    -> Maybe Int
                                                    -> Maybe Int
                                                    -> Handler (MarkupM ()))
                                                   :<|> ((Maybe Text
                                                          -> UUID -> Handler (MarkupM ()))
                                                         :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                               :<|> ((Maybe Text
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Set-Cookie" Text
                                                                                 : Header
                                                                                     "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))
                                                                     :<|> ((Maybe Text
                                                                            -> MultipartData Mem
                                                                            -> Handler
                                                                                 (Headers
                                                                                    (Header
                                                                                       "Set-Cookie"
                                                                                       Text
                                                                                       : Header
                                                                                           "Location"
                                                                                           Text
                                                                                       : NoIx)
                                                                                    NoContent))
                                                                           :<|> ((Maybe Text
                                                                                  -> MultipartData
                                                                                       Mem
                                                                                  -> Handler
                                                                                       (Headers
                                                                                          (Header
                                                                                             "Set-Cookie"
                                                                                             Text
                                                                                             : Header
                                                                                                 "Location"
                                                                                                 Text
                                                                                             : NoIx)
                                                                                          NoContent))
                                                                                 :<|> ((Maybe Text
                                                                                        -> MultipartData
                                                                                             Mem
                                                                                        -> Handler
                                                                                             (Headers
                                                                                                (Header
                                                                                                   "Set-Cookie"
                                                                                                   Text
                                                                                                   : Header
                                                                                                       "Location"
                                                                                                       Text
                                                                                                   : NoIx)
                                                                                                NoContent))
                                                                                       :<|> ((Maybe
                                                                                                Text
                                                                                              -> MultipartData
                                                                                                   Mem
                                                                                              -> Handler
                                                                                                   (Headers
                                                                                                      (Header
                                                                                                         "Set-Cookie"
                                                                                                         Text
                                                                                                         : Header
                                                                                                             "Location"
                                                                                                             Text
                                                                                                         : NoIx)
                                                                                                      NoContent))
                                                                                             :<|> ((Maybe
                                                                                                      Text
                                                                                                    -> MultipartData
                                                                                                         Mem
                                                                                                    -> Handler
                                                                                                         (Headers
                                                                                                            (Header
                                                                                                               "Set-Cookie"
                                                                                                               Text
                                                                                                               : Header
                                                                                                                   "Location"
                                                                                                                   Text
                                                                                                               : NoIx)
                                                                                                            NoContent))
                                                                                                   :<|> ((Maybe
                                                                                                            Text
                                                                                                          -> MultipartData
                                                                                                               Mem
                                                                                                          -> Handler
                                                                                                               (Headers
                                                                                                                  (Header
                                                                                                                     "Set-Cookie"
                                                                                                                     Text
                                                                                                                     : Header
                                                                                                                         "Location"
                                                                                                                         Text
                                                                                                                     : NoIx)
                                                                                                                  NoContent))
                                                                                                         :<|> ((Maybe
                                                                                                                  Text
                                                                                                                -> Handler
                                                                                                                     (MarkupM
                                                                                                                        ()))
                                                                                                               :<|> (MultipartData
                                                                                                                       Mem
                                                                                                                     -> Handler
                                                                                                                          (Headers
                                                                                                                             (Header
                                                                                                                                "Set-Cookie"
                                                                                                                                Text
                                                                                                                                : Header
                                                                                                                                    "Location"
                                                                                                                                    Text
                                                                                                                                : NoIx)
                                                                                                                             NoContent))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> m (MarkupM ())
artistCreateRoute Env
env
    (Maybe Text -> Handler (MarkupM ()))
-> ((Maybe Text
     -> MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> ((Maybe Text
           -> Maybe Text
           -> UUID
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> ((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> ((Maybe Text
                       -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                      :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                            :<|> ((Maybe Text -> Handler (MarkupM ()))
                                  :<|> ((Maybe Text
                                         -> Maybe Text
                                         -> Maybe Int
                                         -> Maybe Int
                                         -> Handler (MarkupM ()))
                                        :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                              :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                    :<|> ((Maybe Text
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Set-Cookie" Text
                                                                      : Header "Location" Text
                                                                      : NoIx)
                                                                   NoContent))
                                                          :<|> ((Maybe Text
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Set-Cookie" Text
                                                                            : Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))
                                                                :<|> ((Maybe Text
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Set-Cookie" Text
                                                                                  : Header
                                                                                      "Location"
                                                                                      Text
                                                                                  : NoIx)
                                                                               NoContent))
                                                                      :<|> ((Maybe Text
                                                                             -> MultipartData Mem
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Set-Cookie"
                                                                                        Text
                                                                                        : Header
                                                                                            "Location"
                                                                                            Text
                                                                                        : NoIx)
                                                                                     NoContent))
                                                                            :<|> ((Maybe Text
                                                                                   -> MultipartData
                                                                                        Mem
                                                                                   -> Handler
                                                                                        (Headers
                                                                                           (Header
                                                                                              "Set-Cookie"
                                                                                              Text
                                                                                              : Header
                                                                                                  "Location"
                                                                                                  Text
                                                                                              : NoIx)
                                                                                           NoContent))
                                                                                  :<|> ((Maybe Text
                                                                                         -> MultipartData
                                                                                              Mem
                                                                                         -> Handler
                                                                                              (Headers
                                                                                                 (Header
                                                                                                    "Set-Cookie"
                                                                                                    Text
                                                                                                    : Header
                                                                                                        "Location"
                                                                                                        Text
                                                                                                    : NoIx)
                                                                                                 NoContent))
                                                                                        :<|> ((Maybe
                                                                                                 Text
                                                                                               -> MultipartData
                                                                                                    Mem
                                                                                               -> Handler
                                                                                                    (Headers
                                                                                                       (Header
                                                                                                          "Set-Cookie"
                                                                                                          Text
                                                                                                          : Header
                                                                                                              "Location"
                                                                                                              Text
                                                                                                          : NoIx)
                                                                                                       NoContent))
                                                                                              :<|> ((Maybe
                                                                                                       Text
                                                                                                     -> Handler
                                                                                                          (MarkupM
                                                                                                             ()))
                                                                                                    :<|> (MultipartData
                                                                                                            Mem
                                                                                                          -> Handler
                                                                                                               (Headers
                                                                                                                  (Header
                                                                                                                     "Set-Cookie"
                                                                                                                     Text
                                                                                                                     : Header
                                                                                                                         "Location"
                                                                                                                         Text
                                                                                                                     : NoIx)
                                                                                                                  NoContent)))))))))))))))))))
-> (Maybe Text -> Handler (MarkupM ()))
   :<|> ((Maybe Text
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((Maybe Text
                -> Maybe Text
                -> UUID
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> ((Maybe Text
                      -> Maybe Text
                      -> UUID
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                     :<|> ((Maybe Text
                            -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                           :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                 :<|> ((Maybe Text -> Handler (MarkupM ()))
                                       :<|> ((Maybe Text
                                              -> Maybe Text
                                              -> Maybe Int
                                              -> Maybe Int
                                              -> Handler (MarkupM ()))
                                             :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                                   :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                         :<|> ((Maybe Text
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Set-Cookie" Text
                                                                           : Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))
                                                               :<|> ((Maybe Text
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Set-Cookie" Text
                                                                                 : Header
                                                                                     "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))
                                                                     :<|> ((Maybe Text
                                                                            -> MultipartData Mem
                                                                            -> Handler
                                                                                 (Headers
                                                                                    (Header
                                                                                       "Set-Cookie"
                                                                                       Text
                                                                                       : Header
                                                                                           "Location"
                                                                                           Text
                                                                                       : NoIx)
                                                                                    NoContent))
                                                                           :<|> ((Maybe Text
                                                                                  -> MultipartData
                                                                                       Mem
                                                                                  -> Handler
                                                                                       (Headers
                                                                                          (Header
                                                                                             "Set-Cookie"
                                                                                             Text
                                                                                             : Header
                                                                                                 "Location"
                                                                                                 Text
                                                                                             : NoIx)
                                                                                          NoContent))
                                                                                 :<|> ((Maybe Text
                                                                                        -> MultipartData
                                                                                             Mem
                                                                                        -> Handler
                                                                                             (Headers
                                                                                                (Header
                                                                                                   "Set-Cookie"
                                                                                                   Text
                                                                                                   : Header
                                                                                                       "Location"
                                                                                                       Text
                                                                                                   : NoIx)
                                                                                                NoContent))
                                                                                       :<|> ((Maybe
                                                                                                Text
                                                                                              -> MultipartData
                                                                                                   Mem
                                                                                              -> Handler
                                                                                                   (Headers
                                                                                                      (Header
                                                                                                         "Set-Cookie"
                                                                                                         Text
                                                                                                         : Header
                                                                                                             "Location"
                                                                                                             Text
                                                                                                         : NoIx)
                                                                                                      NoContent))
                                                                                             :<|> ((Maybe
                                                                                                      Text
                                                                                                    -> MultipartData
                                                                                                         Mem
                                                                                                    -> Handler
                                                                                                         (Headers
                                                                                                            (Header
                                                                                                               "Set-Cookie"
                                                                                                               Text
                                                                                                               : Header
                                                                                                                   "Location"
                                                                                                                   Text
                                                                                                               : NoIx)
                                                                                                            NoContent))
                                                                                                   :<|> ((Maybe
                                                                                                            Text
                                                                                                          -> Handler
                                                                                                               (MarkupM
                                                                                                                  ()))
                                                                                                         :<|> (MultipartData
                                                                                                                 Mem
                                                                                                               -> Handler
                                                                                                                    (Headers
                                                                                                                       (Header
                                                                                                                          "Set-Cookie"
                                                                                                                          Text
                                                                                                                          : Header
                                                                                                                              "Location"
                                                                                                                              Text
                                                                                                                          : NoIx)
                                                                                                                       NoContent)))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> MultipartData tag -> m a
artistCreateFormRoute Env
env
    (Maybe Text
 -> MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> ((Maybe Text
           -> Maybe Text
           -> UUID
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> ((Maybe Text
                 -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                      :<|> ((Maybe Text -> Handler (MarkupM ()))
                            :<|> ((Maybe Text
                                   -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                                  :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                        :<|> ((Maybe Text -> Handler (MarkupM ()))
                                              :<|> ((Maybe Text
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Set-Cookie" Text
                                                                : Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((Maybe Text
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Set-Cookie" Text
                                                                      : Header "Location" Text
                                                                      : NoIx)
                                                                   NoContent))
                                                          :<|> ((Maybe Text
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Set-Cookie" Text
                                                                            : Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))
                                                                :<|> ((Maybe Text
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Set-Cookie" Text
                                                                                  : Header
                                                                                      "Location"
                                                                                      Text
                                                                                  : NoIx)
                                                                               NoContent))
                                                                      :<|> ((Maybe Text
                                                                             -> MultipartData Mem
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Set-Cookie"
                                                                                        Text
                                                                                        : Header
                                                                                            "Location"
                                                                                            Text
                                                                                        : NoIx)
                                                                                     NoContent))
                                                                            :<|> ((Maybe Text
                                                                                   -> MultipartData
                                                                                        Mem
                                                                                   -> Handler
                                                                                        (Headers
                                                                                           (Header
                                                                                              "Set-Cookie"
                                                                                              Text
                                                                                              : Header
                                                                                                  "Location"
                                                                                                  Text
                                                                                              : NoIx)
                                                                                           NoContent))
                                                                                  :<|> ((Maybe Text
                                                                                         -> MultipartData
                                                                                              Mem
                                                                                         -> Handler
                                                                                              (Headers
                                                                                                 (Header
                                                                                                    "Set-Cookie"
                                                                                                    Text
                                                                                                    : Header
                                                                                                        "Location"
                                                                                                        Text
                                                                                                    : NoIx)
                                                                                                 NoContent))
                                                                                        :<|> ((Maybe
                                                                                                 Text
                                                                                               -> Handler
                                                                                                    (MarkupM
                                                                                                       ()))
                                                                                              :<|> (MultipartData
                                                                                                      Mem
                                                                                                    -> Handler
                                                                                                         (Headers
                                                                                                            (Header
                                                                                                               "Set-Cookie"
                                                                                                               Text
                                                                                                               : Header
                                                                                                                   "Location"
                                                                                                                   Text
                                                                                                               : NoIx)
                                                                                                            NoContent))))))))))))))))))
-> (Maybe Text
    -> MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((Maybe Text
          -> Maybe Text
          -> UUID
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((Maybe Text
                -> Maybe Text
                -> UUID
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> ((Maybe Text
                      -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                     :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                           :<|> ((Maybe Text -> Handler (MarkupM ()))
                                 :<|> ((Maybe Text
                                        -> Maybe Text
                                        -> Maybe Int
                                        -> Maybe Int
                                        -> Handler (MarkupM ()))
                                       :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                             :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                   :<|> ((Maybe Text
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Set-Cookie" Text
                                                                     : Header "Location" Text
                                                                     : NoIx)
                                                                  NoContent))
                                                         :<|> ((Maybe Text
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Set-Cookie" Text
                                                                           : Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))
                                                               :<|> ((Maybe Text
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Set-Cookie" Text
                                                                                 : Header
                                                                                     "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))
                                                                     :<|> ((Maybe Text
                                                                            -> MultipartData Mem
                                                                            -> Handler
                                                                                 (Headers
                                                                                    (Header
                                                                                       "Set-Cookie"
                                                                                       Text
                                                                                       : Header
                                                                                           "Location"
                                                                                           Text
                                                                                       : NoIx)
                                                                                    NoContent))
                                                                           :<|> ((Maybe Text
                                                                                  -> MultipartData
                                                                                       Mem
                                                                                  -> Handler
                                                                                       (Headers
                                                                                          (Header
                                                                                             "Set-Cookie"
                                                                                             Text
                                                                                             : Header
                                                                                                 "Location"
                                                                                                 Text
                                                                                             : NoIx)
                                                                                          NoContent))
                                                                                 :<|> ((Maybe Text
                                                                                        -> MultipartData
                                                                                             Mem
                                                                                        -> Handler
                                                                                             (Headers
                                                                                                (Header
                                                                                                   "Set-Cookie"
                                                                                                   Text
                                                                                                   : Header
                                                                                                       "Location"
                                                                                                       Text
                                                                                                   : NoIx)
                                                                                                NoContent))
                                                                                       :<|> ((Maybe
                                                                                                Text
                                                                                              -> MultipartData
                                                                                                   Mem
                                                                                              -> Handler
                                                                                                   (Headers
                                                                                                      (Header
                                                                                                         "Set-Cookie"
                                                                                                         Text
                                                                                                         : Header
                                                                                                             "Location"
                                                                                                             Text
                                                                                                         : NoIx)
                                                                                                      NoContent))
                                                                                             :<|> ((Maybe
                                                                                                      Text
                                                                                                    -> Handler
                                                                                                         (MarkupM
                                                                                                            ()))
                                                                                                   :<|> (MultipartData
                                                                                                           Mem
                                                                                                         -> Handler
                                                                                                              (Headers
                                                                                                                 (Header
                                                                                                                    "Set-Cookie"
                                                                                                                    Text
                                                                                                                    : Header
                                                                                                                        "Location"
                                                                                                                        Text
                                                                                                                    : NoIx)
                                                                                                                 NoContent))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> UUID
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> m a
artistLikeRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> UUID
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> ((Maybe Text
           -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
          :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                :<|> ((Maybe Text -> Handler (MarkupM ()))
                      :<|> ((Maybe Text
                             -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                            :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                  :<|> ((Maybe Text -> Handler (MarkupM ()))
                                        :<|> ((Maybe Text
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Set-Cookie" Text
                                                          : Header "Location" Text : NoIx)
                                                       NoContent))
                                              :<|> ((Maybe Text
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Set-Cookie" Text
                                                                : Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((Maybe Text
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Set-Cookie" Text
                                                                      : Header "Location" Text
                                                                      : NoIx)
                                                                   NoContent))
                                                          :<|> ((Maybe Text
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Set-Cookie" Text
                                                                            : Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))
                                                                :<|> ((Maybe Text
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Set-Cookie" Text
                                                                                  : Header
                                                                                      "Location"
                                                                                      Text
                                                                                  : NoIx)
                                                                               NoContent))
                                                                      :<|> ((Maybe Text
                                                                             -> MultipartData Mem
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Set-Cookie"
                                                                                        Text
                                                                                        : Header
                                                                                            "Location"
                                                                                            Text
                                                                                        : NoIx)
                                                                                     NoContent))
                                                                            :<|> ((Maybe Text
                                                                                   -> MultipartData
                                                                                        Mem
                                                                                   -> Handler
                                                                                        (Headers
                                                                                           (Header
                                                                                              "Set-Cookie"
                                                                                              Text
                                                                                              : Header
                                                                                                  "Location"
                                                                                                  Text
                                                                                              : NoIx)
                                                                                           NoContent))
                                                                                  :<|> ((Maybe Text
                                                                                         -> Handler
                                                                                              (MarkupM
                                                                                                 ()))
                                                                                        :<|> (MultipartData
                                                                                                Mem
                                                                                              -> Handler
                                                                                                   (Headers
                                                                                                      (Header
                                                                                                         "Set-Cookie"
                                                                                                         Text
                                                                                                         : Header
                                                                                                             "Location"
                                                                                                             Text
                                                                                                         : NoIx)
                                                                                                      NoContent)))))))))))))))))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((Maybe Text
          -> Maybe Text
          -> UUID
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((Maybe Text
                -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
               :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                     :<|> ((Maybe Text -> Handler (MarkupM ()))
                           :<|> ((Maybe Text
                                  -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                                 :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                       :<|> ((Maybe Text -> Handler (MarkupM ()))
                                             :<|> ((Maybe Text
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Set-Cookie" Text
                                                               : Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> ((Maybe Text
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Set-Cookie" Text
                                                                     : Header "Location" Text
                                                                     : NoIx)
                                                                  NoContent))
                                                         :<|> ((Maybe Text
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Set-Cookie" Text
                                                                           : Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))
                                                               :<|> ((Maybe Text
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Set-Cookie" Text
                                                                                 : Header
                                                                                     "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))
                                                                     :<|> ((Maybe Text
                                                                            -> MultipartData Mem
                                                                            -> Handler
                                                                                 (Headers
                                                                                    (Header
                                                                                       "Set-Cookie"
                                                                                       Text
                                                                                       : Header
                                                                                           "Location"
                                                                                           Text
                                                                                       : NoIx)
                                                                                    NoContent))
                                                                           :<|> ((Maybe Text
                                                                                  -> MultipartData
                                                                                       Mem
                                                                                  -> Handler
                                                                                       (Headers
                                                                                          (Header
                                                                                             "Set-Cookie"
                                                                                             Text
                                                                                             : Header
                                                                                                 "Location"
                                                                                                 Text
                                                                                             : NoIx)
                                                                                          NoContent))
                                                                                 :<|> ((Maybe Text
                                                                                        -> MultipartData
                                                                                             Mem
                                                                                        -> Handler
                                                                                             (Headers
                                                                                                (Header
                                                                                                   "Set-Cookie"
                                                                                                   Text
                                                                                                   : Header
                                                                                                       "Location"
                                                                                                       Text
                                                                                                   : NoIx)
                                                                                                NoContent))
                                                                                       :<|> ((Maybe
                                                                                                Text
                                                                                              -> Handler
                                                                                                   (MarkupM
                                                                                                      ()))
                                                                                             :<|> (MultipartData
                                                                                                     Mem
                                                                                                   -> Handler
                                                                                                        (Headers
                                                                                                           (Header
                                                                                                              "Set-Cookie"
                                                                                                              Text
                                                                                                              : Header
                                                                                                                  "Location"
                                                                                                                  Text
                                                                                                              : NoIx)
                                                                                                           NoContent)))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> UUID
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> m a
artistDislikeRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> UUID
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text
     -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
    :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
          :<|> ((Maybe Text -> Handler (MarkupM ()))
                :<|> ((Maybe Text
                       -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                      :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                            :<|> ((Maybe Text -> Handler (MarkupM ()))
                                  :<|> ((Maybe Text
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers
                                                 (Header "Set-Cookie" Text
                                                    : Header "Location" Text : NoIx)
                                                 NoContent))
                                        :<|> ((Maybe Text
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Set-Cookie" Text
                                                          : Header "Location" Text : NoIx)
                                                       NoContent))
                                              :<|> ((Maybe Text
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Set-Cookie" Text
                                                                : Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((Maybe Text
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Set-Cookie" Text
                                                                      : Header "Location" Text
                                                                      : NoIx)
                                                                   NoContent))
                                                          :<|> ((Maybe Text
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Set-Cookie" Text
                                                                            : Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))
                                                                :<|> ((Maybe Text
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Set-Cookie" Text
                                                                                  : Header
                                                                                      "Location"
                                                                                      Text
                                                                                  : NoIx)
                                                                               NoContent))
                                                                      :<|> ((Maybe Text
                                                                             -> MultipartData Mem
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Set-Cookie"
                                                                                        Text
                                                                                        : Header
                                                                                            "Location"
                                                                                            Text
                                                                                        : NoIx)
                                                                                     NoContent))
                                                                            :<|> ((Maybe Text
                                                                                   -> Handler
                                                                                        (MarkupM
                                                                                           ()))
                                                                                  :<|> (MultipartData
                                                                                          Mem
                                                                                        -> Handler
                                                                                             (Headers
                                                                                                (Header
                                                                                                   "Set-Cookie"
                                                                                                   Text
                                                                                                   : Header
                                                                                                       "Location"
                                                                                                       Text
                                                                                                   : NoIx)
                                                                                                NoContent))))))))))))))))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((Maybe Text
          -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
         :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
               :<|> ((Maybe Text -> Handler (MarkupM ()))
                     :<|> ((Maybe Text
                            -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                           :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                                 :<|> ((Maybe Text -> Handler (MarkupM ()))
                                       :<|> ((Maybe Text
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Set-Cookie" Text
                                                         : Header "Location" Text : NoIx)
                                                      NoContent))
                                             :<|> ((Maybe Text
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Set-Cookie" Text
                                                               : Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> ((Maybe Text
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Set-Cookie" Text
                                                                     : Header "Location" Text
                                                                     : NoIx)
                                                                  NoContent))
                                                         :<|> ((Maybe Text
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Set-Cookie" Text
                                                                           : Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))
                                                               :<|> ((Maybe Text
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Set-Cookie" Text
                                                                                 : Header
                                                                                     "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))
                                                                     :<|> ((Maybe Text
                                                                            -> MultipartData Mem
                                                                            -> Handler
                                                                                 (Headers
                                                                                    (Header
                                                                                       "Set-Cookie"
                                                                                       Text
                                                                                       : Header
                                                                                           "Location"
                                                                                           Text
                                                                                       : NoIx)
                                                                                    NoContent))
                                                                           :<|> ((Maybe Text
                                                                                  -> MultipartData
                                                                                       Mem
                                                                                  -> Handler
                                                                                       (Headers
                                                                                          (Header
                                                                                             "Set-Cookie"
                                                                                             Text
                                                                                             : Header
                                                                                                 "Location"
                                                                                                 Text
                                                                                             : NoIx)
                                                                                          NoContent))
                                                                                 :<|> ((Maybe Text
                                                                                        -> Handler
                                                                                             (MarkupM
                                                                                                ()))
                                                                                       :<|> (MultipartData
                                                                                               Mem
                                                                                             -> Handler
                                                                                                  (Headers
                                                                                                     (Header
                                                                                                        "Set-Cookie"
                                                                                                        Text
                                                                                                        : Header
                                                                                                            "Location"
                                                                                                            Text
                                                                                                        : NoIx)
                                                                                                     NoContent))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> m (MarkupM ())
genresRoute Env
env
    (Maybe Text
 -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
-> ((Maybe Text -> UUID -> Handler (MarkupM ()))
    :<|> ((Maybe Text -> Handler (MarkupM ()))
          :<|> ((Maybe Text
                 -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                      :<|> ((Maybe Text -> Handler (MarkupM ()))
                            :<|> ((Maybe Text
                                   -> MultipartData Mem
                                   -> Handler
                                        (Headers
                                           (Header "Set-Cookie" Text
                                              : Header "Location" Text : NoIx)
                                           NoContent))
                                  :<|> ((Maybe Text
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers
                                                 (Header "Set-Cookie" Text
                                                    : Header "Location" Text : NoIx)
                                                 NoContent))
                                        :<|> ((Maybe Text
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Set-Cookie" Text
                                                          : Header "Location" Text : NoIx)
                                                       NoContent))
                                              :<|> ((Maybe Text
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Set-Cookie" Text
                                                                : Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((Maybe Text
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Set-Cookie" Text
                                                                      : Header "Location" Text
                                                                      : NoIx)
                                                                   NoContent))
                                                          :<|> ((Maybe Text
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Set-Cookie" Text
                                                                            : Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))
                                                                :<|> ((Maybe Text
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Set-Cookie" Text
                                                                                  : Header
                                                                                      "Location"
                                                                                      Text
                                                                                  : NoIx)
                                                                               NoContent))
                                                                      :<|> ((Maybe Text
                                                                             -> Handler
                                                                                  (MarkupM ()))
                                                                            :<|> (MultipartData Mem
                                                                                  -> Handler
                                                                                       (Headers
                                                                                          (Header
                                                                                             "Set-Cookie"
                                                                                             Text
                                                                                             : Header
                                                                                                 "Location"
                                                                                                 Text
                                                                                             : NoIx)
                                                                                          NoContent)))))))))))))))
-> (Maybe Text
    -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
   :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
         :<|> ((Maybe Text -> Handler (MarkupM ()))
               :<|> ((Maybe Text
                      -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
                     :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                           :<|> ((Maybe Text -> Handler (MarkupM ()))
                                 :<|> ((Maybe Text
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers
                                                (Header "Set-Cookie" Text
                                                   : Header "Location" Text : NoIx)
                                                NoContent))
                                       :<|> ((Maybe Text
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Set-Cookie" Text
                                                         : Header "Location" Text : NoIx)
                                                      NoContent))
                                             :<|> ((Maybe Text
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Set-Cookie" Text
                                                               : Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> ((Maybe Text
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Set-Cookie" Text
                                                                     : Header "Location" Text
                                                                     : NoIx)
                                                                  NoContent))
                                                         :<|> ((Maybe Text
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Set-Cookie" Text
                                                                           : Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))
                                                               :<|> ((Maybe Text
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Set-Cookie" Text
                                                                                 : Header
                                                                                     "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))
                                                                     :<|> ((Maybe Text
                                                                            -> MultipartData Mem
                                                                            -> Handler
                                                                                 (Headers
                                                                                    (Header
                                                                                       "Set-Cookie"
                                                                                       Text
                                                                                       : Header
                                                                                           "Location"
                                                                                           Text
                                                                                       : NoIx)
                                                                                    NoContent))
                                                                           :<|> ((Maybe Text
                                                                                  -> Handler
                                                                                       (MarkupM ()))
                                                                                 :<|> (MultipartData
                                                                                         Mem
                                                                                       -> Handler
                                                                                            (Headers
                                                                                               (Header
                                                                                                  "Set-Cookie"
                                                                                                  Text
                                                                                                  : Header
                                                                                                      "Location"
                                                                                                      Text
                                                                                                  : NoIx)
                                                                                               NoContent)))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> UUID -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> UUID -> m (MarkupM ())
genreRoute Env
env
    (Maybe Text -> UUID -> Handler (MarkupM ()))
-> ((Maybe Text -> Handler (MarkupM ()))
    :<|> ((Maybe Text
           -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
          :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                :<|> ((Maybe Text -> Handler (MarkupM ()))
                      :<|> ((Maybe Text
                             -> MultipartData Mem
                             -> Handler
                                  (Headers
                                     (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                     NoContent))
                            :<|> ((Maybe Text
                                   -> MultipartData Mem
                                   -> Handler
                                        (Headers
                                           (Header "Set-Cookie" Text
                                              : Header "Location" Text : NoIx)
                                           NoContent))
                                  :<|> ((Maybe Text
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers
                                                 (Header "Set-Cookie" Text
                                                    : Header "Location" Text : NoIx)
                                                 NoContent))
                                        :<|> ((Maybe Text
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Set-Cookie" Text
                                                          : Header "Location" Text : NoIx)
                                                       NoContent))
                                              :<|> ((Maybe Text
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Set-Cookie" Text
                                                                : Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((Maybe Text
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Set-Cookie" Text
                                                                      : Header "Location" Text
                                                                      : NoIx)
                                                                   NoContent))
                                                          :<|> ((Maybe Text
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Set-Cookie" Text
                                                                            : Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))
                                                                :<|> ((Maybe Text
                                                                       -> Handler (MarkupM ()))
                                                                      :<|> (MultipartData Mem
                                                                            -> Handler
                                                                                 (Headers
                                                                                    (Header
                                                                                       "Set-Cookie"
                                                                                       Text
                                                                                       : Header
                                                                                           "Location"
                                                                                           Text
                                                                                       : NoIx)
                                                                                    NoContent))))))))))))))
-> (Maybe Text -> UUID -> Handler (MarkupM ()))
   :<|> ((Maybe Text -> Handler (MarkupM ()))
         :<|> ((Maybe Text
                -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
               :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
                     :<|> ((Maybe Text -> Handler (MarkupM ()))
                           :<|> ((Maybe Text
                                  -> MultipartData Mem
                                  -> Handler
                                       (Headers
                                          (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                          NoContent))
                                 :<|> ((Maybe Text
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers
                                                (Header "Set-Cookie" Text
                                                   : Header "Location" Text : NoIx)
                                                NoContent))
                                       :<|> ((Maybe Text
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Set-Cookie" Text
                                                         : Header "Location" Text : NoIx)
                                                      NoContent))
                                             :<|> ((Maybe Text
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Set-Cookie" Text
                                                               : Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> ((Maybe Text
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Set-Cookie" Text
                                                                     : Header "Location" Text
                                                                     : NoIx)
                                                                  NoContent))
                                                         :<|> ((Maybe Text
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Set-Cookie" Text
                                                                           : Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))
                                                               :<|> ((Maybe Text
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Set-Cookie" Text
                                                                                 : Header
                                                                                     "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))
                                                                     :<|> ((Maybe Text
                                                                            -> Handler (MarkupM ()))
                                                                           :<|> (MultipartData Mem
                                                                                 -> Handler
                                                                                      (Headers
                                                                                         (Header
                                                                                            "Set-Cookie"
                                                                                            Text
                                                                                            : Header
                                                                                                "Location"
                                                                                                Text
                                                                                            : NoIx)
                                                                                         NoContent))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> m (MarkupM ())
genreCreateRoute Env
env
    (Maybe Text -> Handler (MarkupM ()))
-> ((Maybe Text
     -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
    :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
          :<|> ((Maybe Text -> Handler (MarkupM ()))
                :<|> ((Maybe Text
                       -> MultipartData Mem
                       -> Handler
                            (Headers
                               (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                               NoContent))
                      :<|> ((Maybe Text
                             -> MultipartData Mem
                             -> Handler
                                  (Headers
                                     (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                     NoContent))
                            :<|> ((Maybe Text
                                   -> MultipartData Mem
                                   -> Handler
                                        (Headers
                                           (Header "Set-Cookie" Text
                                              : Header "Location" Text : NoIx)
                                           NoContent))
                                  :<|> ((Maybe Text
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers
                                                 (Header "Set-Cookie" Text
                                                    : Header "Location" Text : NoIx)
                                                 NoContent))
                                        :<|> ((Maybe Text
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Set-Cookie" Text
                                                          : Header "Location" Text : NoIx)
                                                       NoContent))
                                              :<|> ((Maybe Text
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Set-Cookie" Text
                                                                : Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((Maybe Text
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Set-Cookie" Text
                                                                      : Header "Location" Text
                                                                      : NoIx)
                                                                   NoContent))
                                                          :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                                :<|> (MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Set-Cookie" Text
                                                                                 : Header
                                                                                     "Location" Text
                                                                                 : NoIx)
                                                                              NoContent)))))))))))))
-> (Maybe Text -> Handler (MarkupM ()))
   :<|> ((Maybe Text
          -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
         :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
               :<|> ((Maybe Text -> Handler (MarkupM ()))
                     :<|> ((Maybe Text
                            -> MultipartData Mem
                            -> Handler
                                 (Headers
                                    (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                    NoContent))
                           :<|> ((Maybe Text
                                  -> MultipartData Mem
                                  -> Handler
                                       (Headers
                                          (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                          NoContent))
                                 :<|> ((Maybe Text
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers
                                                (Header "Set-Cookie" Text
                                                   : Header "Location" Text : NoIx)
                                                NoContent))
                                       :<|> ((Maybe Text
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Set-Cookie" Text
                                                         : Header "Location" Text : NoIx)
                                                      NoContent))
                                             :<|> ((Maybe Text
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Set-Cookie" Text
                                                               : Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> ((Maybe Text
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Set-Cookie" Text
                                                                     : Header "Location" Text
                                                                     : NoIx)
                                                                  NoContent))
                                                         :<|> ((Maybe Text
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Set-Cookie" Text
                                                                           : Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))
                                                               :<|> ((Maybe Text
                                                                      -> Handler (MarkupM ()))
                                                                     :<|> (MultipartData Mem
                                                                           -> Handler
                                                                                (Headers
                                                                                   (Header
                                                                                      "Set-Cookie"
                                                                                      Text
                                                                                      : Header
                                                                                          "Location"
                                                                                          Text
                                                                                      : NoIx)
                                                                                   NoContent)))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> m (MarkupM ())
songsRoute Env
env
    (Maybe Text
 -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
-> ((Maybe Text -> UUID -> Handler (MarkupM ()))
    :<|> ((Maybe Text -> Handler (MarkupM ()))
          :<|> ((Maybe Text
                 -> MultipartData Mem
                 -> Handler
                      (Headers
                         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                         NoContent))
                :<|> ((Maybe Text
                       -> MultipartData Mem
                       -> Handler
                            (Headers
                               (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                               NoContent))
                      :<|> ((Maybe Text
                             -> MultipartData Mem
                             -> Handler
                                  (Headers
                                     (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                     NoContent))
                            :<|> ((Maybe Text
                                   -> MultipartData Mem
                                   -> Handler
                                        (Headers
                                           (Header "Set-Cookie" Text
                                              : Header "Location" Text : NoIx)
                                           NoContent))
                                  :<|> ((Maybe Text
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers
                                                 (Header "Set-Cookie" Text
                                                    : Header "Location" Text : NoIx)
                                                 NoContent))
                                        :<|> ((Maybe Text
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Set-Cookie" Text
                                                          : Header "Location" Text : NoIx)
                                                       NoContent))
                                              :<|> ((Maybe Text
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Set-Cookie" Text
                                                                : Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                          :<|> (MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Set-Cookie" Text
                                                                           : Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))))))))))))
-> (Maybe Text
    -> Maybe Text -> Maybe Int -> Maybe Int -> Handler (MarkupM ()))
   :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
         :<|> ((Maybe Text -> Handler (MarkupM ()))
               :<|> ((Maybe Text
                      -> MultipartData Mem
                      -> Handler
                           (Headers
                              (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                              NoContent))
                     :<|> ((Maybe Text
                            -> MultipartData Mem
                            -> Handler
                                 (Headers
                                    (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                    NoContent))
                           :<|> ((Maybe Text
                                  -> MultipartData Mem
                                  -> Handler
                                       (Headers
                                          (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                          NoContent))
                                 :<|> ((Maybe Text
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers
                                                (Header "Set-Cookie" Text
                                                   : Header "Location" Text : NoIx)
                                                NoContent))
                                       :<|> ((Maybe Text
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Set-Cookie" Text
                                                         : Header "Location" Text : NoIx)
                                                      NoContent))
                                             :<|> ((Maybe Text
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Set-Cookie" Text
                                                               : Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> ((Maybe Text
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Set-Cookie" Text
                                                                     : Header "Location" Text
                                                                     : NoIx)
                                                                  NoContent))
                                                         :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                               :<|> (MultipartData Mem
                                                                     -> Handler
                                                                          (Headers
                                                                             (Header
                                                                                "Set-Cookie" Text
                                                                                : Header
                                                                                    "Location" Text
                                                                                : NoIx)
                                                                             NoContent))))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> UUID -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> UUID -> m (MarkupM ())
songRoute Env
env
    (Maybe Text -> UUID -> Handler (MarkupM ()))
-> ((Maybe Text -> Handler (MarkupM ()))
    :<|> ((Maybe Text
           -> MultipartData Mem
           -> Handler
                (Headers
                   (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                   NoContent))
          :<|> ((Maybe Text
                 -> MultipartData Mem
                 -> Handler
                      (Headers
                         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                         NoContent))
                :<|> ((Maybe Text
                       -> MultipartData Mem
                       -> Handler
                            (Headers
                               (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                               NoContent))
                      :<|> ((Maybe Text
                             -> MultipartData Mem
                             -> Handler
                                  (Headers
                                     (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                     NoContent))
                            :<|> ((Maybe Text
                                   -> MultipartData Mem
                                   -> Handler
                                        (Headers
                                           (Header "Set-Cookie" Text
                                              : Header "Location" Text : NoIx)
                                           NoContent))
                                  :<|> ((Maybe Text
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers
                                                 (Header "Set-Cookie" Text
                                                    : Header "Location" Text : NoIx)
                                                 NoContent))
                                        :<|> ((Maybe Text
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Set-Cookie" Text
                                                          : Header "Location" Text : NoIx)
                                                       NoContent))
                                              :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                    :<|> (MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Set-Cookie" Text
                                                                     : Header "Location" Text
                                                                     : NoIx)
                                                                  NoContent)))))))))))
-> (Maybe Text -> UUID -> Handler (MarkupM ()))
   :<|> ((Maybe Text -> Handler (MarkupM ()))
         :<|> ((Maybe Text
                -> MultipartData Mem
                -> Handler
                     (Headers
                        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                        NoContent))
               :<|> ((Maybe Text
                      -> MultipartData Mem
                      -> Handler
                           (Headers
                              (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                              NoContent))
                     :<|> ((Maybe Text
                            -> MultipartData Mem
                            -> Handler
                                 (Headers
                                    (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                    NoContent))
                           :<|> ((Maybe Text
                                  -> MultipartData Mem
                                  -> Handler
                                       (Headers
                                          (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                          NoContent))
                                 :<|> ((Maybe Text
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers
                                                (Header "Set-Cookie" Text
                                                   : Header "Location" Text : NoIx)
                                                NoContent))
                                       :<|> ((Maybe Text
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Set-Cookie" Text
                                                         : Header "Location" Text : NoIx)
                                                      NoContent))
                                             :<|> ((Maybe Text
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Set-Cookie" Text
                                                               : Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                         :<|> (MultipartData Mem
                                                               -> Handler
                                                                    (Headers
                                                                       (Header "Set-Cookie" Text
                                                                          : Header "Location" Text
                                                                          : NoIx)
                                                                       NoContent)))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> m (MarkupM ())
songCreateRoute Env
env
    (Maybe Text -> Handler (MarkupM ()))
-> ((Maybe Text
     -> MultipartData Mem
     -> Handler
          (Headers
             (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
             NoContent))
    :<|> ((Maybe Text
           -> MultipartData Mem
           -> Handler
                (Headers
                   (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                   NoContent))
          :<|> ((Maybe Text
                 -> MultipartData Mem
                 -> Handler
                      (Headers
                         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                         NoContent))
                :<|> ((Maybe Text
                       -> MultipartData Mem
                       -> Handler
                            (Headers
                               (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                               NoContent))
                      :<|> ((Maybe Text
                             -> MultipartData Mem
                             -> Handler
                                  (Headers
                                     (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                     NoContent))
                            :<|> ((Maybe Text
                                   -> MultipartData Mem
                                   -> Handler
                                        (Headers
                                           (Header "Set-Cookie" Text
                                              : Header "Location" Text : NoIx)
                                           NoContent))
                                  :<|> ((Maybe Text
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers
                                                 (Header "Set-Cookie" Text
                                                    : Header "Location" Text : NoIx)
                                                 NoContent))
                                        :<|> ((Maybe Text -> Handler (MarkupM ()))
                                              :<|> (MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Set-Cookie" Text
                                                               : Header "Location" Text : NoIx)
                                                            NoContent))))))))))
-> (Maybe Text -> Handler (MarkupM ()))
   :<|> ((Maybe Text
          -> MultipartData Mem
          -> Handler
               (Headers
                  (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                  NoContent))
         :<|> ((Maybe Text
                -> MultipartData Mem
                -> Handler
                     (Headers
                        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                        NoContent))
               :<|> ((Maybe Text
                      -> MultipartData Mem
                      -> Handler
                           (Headers
                              (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                              NoContent))
                     :<|> ((Maybe Text
                            -> MultipartData Mem
                            -> Handler
                                 (Headers
                                    (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                    NoContent))
                           :<|> ((Maybe Text
                                  -> MultipartData Mem
                                  -> Handler
                                       (Headers
                                          (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                          NoContent))
                                 :<|> ((Maybe Text
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers
                                                (Header "Set-Cookie" Text
                                                   : Header "Location" Text : NoIx)
                                                NoContent))
                                       :<|> ((Maybe Text
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Set-Cookie" Text
                                                         : Header "Location" Text : NoIx)
                                                      NoContent))
                                             :<|> ((Maybe Text -> Handler (MarkupM ()))
                                                   :<|> (MultipartData Mem
                                                         -> Handler
                                                              (Headers
                                                                 (Header "Set-Cookie" Text
                                                                    : Header "Location" Text : NoIx)
                                                                 NoContent))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> MultipartData Mem
-> Handler
     (Headers
        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
        NoContent)
forall (m :: * -> *) tag a.
MonadError ServerError m =>
Env -> Maybe Text -> MultipartData tag -> m a
setLanguageRoute Env
env
    (Maybe Text
 -> MultipartData Mem
 -> Handler
      (Headers
         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
         NoContent))
-> ((Maybe Text
     -> MultipartData Mem
     -> Handler
          (Headers
             (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
             NoContent))
    :<|> ((Maybe Text
           -> MultipartData Mem
           -> Handler
                (Headers
                   (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                   NoContent))
          :<|> ((Maybe Text
                 -> MultipartData Mem
                 -> Handler
                      (Headers
                         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                         NoContent))
                :<|> ((Maybe Text
                       -> MultipartData Mem
                       -> Handler
                            (Headers
                               (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                               NoContent))
                      :<|> ((Maybe Text
                             -> MultipartData Mem
                             -> Handler
                                  (Headers
                                     (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                     NoContent))
                            :<|> ((Maybe Text
                                   -> MultipartData Mem
                                   -> Handler
                                        (Headers
                                           (Header "Set-Cookie" Text
                                              : Header "Location" Text : NoIx)
                                           NoContent))
                                  :<|> ((Maybe Text -> Handler (MarkupM ()))
                                        :<|> (MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Set-Cookie" Text
                                                         : Header "Location" Text : NoIx)
                                                      NoContent)))))))))
-> (Maybe Text
    -> MultipartData Mem
    -> Handler
         (Headers
            (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
            NoContent))
   :<|> ((Maybe Text
          -> MultipartData Mem
          -> Handler
               (Headers
                  (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                  NoContent))
         :<|> ((Maybe Text
                -> MultipartData Mem
                -> Handler
                     (Headers
                        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                        NoContent))
               :<|> ((Maybe Text
                      -> MultipartData Mem
                      -> Handler
                           (Headers
                              (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                              NoContent))
                     :<|> ((Maybe Text
                            -> MultipartData Mem
                            -> Handler
                                 (Headers
                                    (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                    NoContent))
                           :<|> ((Maybe Text
                                  -> MultipartData Mem
                                  -> Handler
                                       (Headers
                                          (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                          NoContent))
                                 :<|> ((Maybe Text
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers
                                                (Header "Set-Cookie" Text
                                                   : Header "Location" Text : NoIx)
                                                NoContent))
                                       :<|> ((Maybe Text -> Handler (MarkupM ()))
                                             :<|> (MultipartData Mem
                                                   -> Handler
                                                        (Headers
                                                           (Header "Set-Cookie" Text
                                                              : Header "Location" Text : NoIx)
                                                           NoContent)))))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> MultipartData Mem
-> Handler
     (Headers
        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
        NoContent)
forall (m :: * -> *) tag a.
MonadError ServerError m =>
Env -> Maybe Text -> MultipartData tag -> m a
setArtistSortingRoute Env
env
    (Maybe Text
 -> MultipartData Mem
 -> Handler
      (Headers
         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
         NoContent))
-> ((Maybe Text
     -> MultipartData Mem
     -> Handler
          (Headers
             (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
             NoContent))
    :<|> ((Maybe Text
           -> MultipartData Mem
           -> Handler
                (Headers
                   (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                   NoContent))
          :<|> ((Maybe Text
                 -> MultipartData Mem
                 -> Handler
                      (Headers
                         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                         NoContent))
                :<|> ((Maybe Text
                       -> MultipartData Mem
                       -> Handler
                            (Headers
                               (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                               NoContent))
                      :<|> ((Maybe Text
                             -> MultipartData Mem
                             -> Handler
                                  (Headers
                                     (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                     NoContent))
                            :<|> ((Maybe Text -> Handler (MarkupM ()))
                                  :<|> (MultipartData Mem
                                        -> Handler
                                             (Headers
                                                (Header "Set-Cookie" Text
                                                   : Header "Location" Text : NoIx)
                                                NoContent))))))))
-> (Maybe Text
    -> MultipartData Mem
    -> Handler
         (Headers
            (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
            NoContent))
   :<|> ((Maybe Text
          -> MultipartData Mem
          -> Handler
               (Headers
                  (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                  NoContent))
         :<|> ((Maybe Text
                -> MultipartData Mem
                -> Handler
                     (Headers
                        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                        NoContent))
               :<|> ((Maybe Text
                      -> MultipartData Mem
                      -> Handler
                           (Headers
                              (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                              NoContent))
                     :<|> ((Maybe Text
                            -> MultipartData Mem
                            -> Handler
                                 (Headers
                                    (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                    NoContent))
                           :<|> ((Maybe Text
                                  -> MultipartData Mem
                                  -> Handler
                                       (Headers
                                          (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                          NoContent))
                                 :<|> ((Maybe Text -> Handler (MarkupM ()))
                                       :<|> (MultipartData Mem
                                             -> Handler
                                                  (Headers
                                                     (Header "Set-Cookie" Text
                                                        : Header "Location" Text : NoIx)
                                                     NoContent))))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> MultipartData Mem
-> Handler
     (Headers
        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
        NoContent)
forall (m :: * -> *) tag a.
MonadError ServerError m =>
Env -> Maybe Text -> MultipartData tag -> m a
setGenreSortingRoute Env
env
    (Maybe Text
 -> MultipartData Mem
 -> Handler
      (Headers
         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
         NoContent))
-> ((Maybe Text
     -> MultipartData Mem
     -> Handler
          (Headers
             (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
             NoContent))
    :<|> ((Maybe Text
           -> MultipartData Mem
           -> Handler
                (Headers
                   (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                   NoContent))
          :<|> ((Maybe Text
                 -> MultipartData Mem
                 -> Handler
                      (Headers
                         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                         NoContent))
                :<|> ((Maybe Text
                       -> MultipartData Mem
                       -> Handler
                            (Headers
                               (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                               NoContent))
                      :<|> ((Maybe Text -> Handler (MarkupM ()))
                            :<|> (MultipartData Mem
                                  -> Handler
                                       (Headers
                                          (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                          NoContent)))))))
-> (Maybe Text
    -> MultipartData Mem
    -> Handler
         (Headers
            (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
            NoContent))
   :<|> ((Maybe Text
          -> MultipartData Mem
          -> Handler
               (Headers
                  (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                  NoContent))
         :<|> ((Maybe Text
                -> MultipartData Mem
                -> Handler
                     (Headers
                        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                        NoContent))
               :<|> ((Maybe Text
                      -> MultipartData Mem
                      -> Handler
                           (Headers
                              (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                              NoContent))
                     :<|> ((Maybe Text
                            -> MultipartData Mem
                            -> Handler
                                 (Headers
                                    (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                    NoContent))
                           :<|> ((Maybe Text -> Handler (MarkupM ()))
                                 :<|> (MultipartData Mem
                                       -> Handler
                                            (Headers
                                               (Header "Set-Cookie" Text
                                                  : Header "Location" Text : NoIx)
                                               NoContent)))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> MultipartData Mem
-> Handler
     (Headers
        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
        NoContent)
forall (m :: * -> *) tag a.
MonadError ServerError m =>
Env -> Maybe Text -> MultipartData tag -> m a
setSongSortingRoute Env
env
    (Maybe Text
 -> MultipartData Mem
 -> Handler
      (Headers
         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
         NoContent))
-> ((Maybe Text
     -> MultipartData Mem
     -> Handler
          (Headers
             (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
             NoContent))
    :<|> ((Maybe Text
           -> MultipartData Mem
           -> Handler
                (Headers
                   (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                   NoContent))
          :<|> ((Maybe Text
                 -> MultipartData Mem
                 -> Handler
                      (Headers
                         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                         NoContent))
                :<|> ((Maybe Text -> Handler (MarkupM ()))
                      :<|> (MultipartData Mem
                            -> Handler
                                 (Headers
                                    (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                    NoContent))))))
-> (Maybe Text
    -> MultipartData Mem
    -> Handler
         (Headers
            (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
            NoContent))
   :<|> ((Maybe Text
          -> MultipartData Mem
          -> Handler
               (Headers
                  (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                  NoContent))
         :<|> ((Maybe Text
                -> MultipartData Mem
                -> Handler
                     (Headers
                        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                        NoContent))
               :<|> ((Maybe Text
                      -> MultipartData Mem
                      -> Handler
                           (Headers
                              (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                              NoContent))
                     :<|> ((Maybe Text -> Handler (MarkupM ()))
                           :<|> (MultipartData Mem
                                 -> Handler
                                      (Headers
                                         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                         NoContent))))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> MultipartData Mem
-> Handler
     (Headers
        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
        NoContent)
forall (m :: * -> *) tag a.
MonadError ServerError m =>
Env -> Maybe Text -> MultipartData tag -> m a
setDarkModeRoute Env
env
    (Maybe Text
 -> MultipartData Mem
 -> Handler
      (Headers
         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
         NoContent))
-> ((Maybe Text
     -> MultipartData Mem
     -> Handler
          (Headers
             (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
             NoContent))
    :<|> ((Maybe Text
           -> MultipartData Mem
           -> Handler
                (Headers
                   (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                   NoContent))
          :<|> ((Maybe Text -> Handler (MarkupM ()))
                :<|> (MultipartData Mem
                      -> Handler
                           (Headers
                              (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                              NoContent)))))
-> (Maybe Text
    -> MultipartData Mem
    -> Handler
         (Headers
            (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
            NoContent))
   :<|> ((Maybe Text
          -> MultipartData Mem
          -> Handler
               (Headers
                  (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                  NoContent))
         :<|> ((Maybe Text
                -> MultipartData Mem
                -> Handler
                     (Headers
                        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                        NoContent))
               :<|> ((Maybe Text -> Handler (MarkupM ()))
                     :<|> (MultipartData Mem
                           -> Handler
                                (Headers
                                   (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                                   NoContent)))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> MultipartData Mem
-> Handler
     (Headers
        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
        NoContent)
forall (m :: * -> *) tag a.
MonadError ServerError m =>
Env -> Maybe Text -> MultipartData tag -> m a
setSongAsciiSizeRoute Env
env
    (Maybe Text
 -> MultipartData Mem
 -> Handler
      (Headers
         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
         NoContent))
-> ((Maybe Text
     -> MultipartData Mem
     -> Handler
          (Headers
             (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
             NoContent))
    :<|> ((Maybe Text -> Handler (MarkupM ()))
          :<|> (MultipartData Mem
                -> Handler
                     (Headers
                        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                        NoContent))))
-> (Maybe Text
    -> MultipartData Mem
    -> Handler
         (Headers
            (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
            NoContent))
   :<|> ((Maybe Text
          -> MultipartData Mem
          -> Handler
               (Headers
                  (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                  NoContent))
         :<|> ((Maybe Text -> Handler (MarkupM ()))
               :<|> (MultipartData Mem
                     -> Handler
                          (Headers
                             (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                             NoContent))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> MultipartData Mem
-> Handler
     (Headers
        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
        NoContent)
forall (m :: * -> *) tag a.
MonadError ServerError m =>
Env -> Maybe Text -> MultipartData tag -> m a
setPaletteRoute Env
env
    (Maybe Text
 -> MultipartData Mem
 -> Handler
      (Headers
         (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
         NoContent))
-> ((Maybe Text -> Handler (MarkupM ()))
    :<|> (MultipartData Mem
          -> Handler
               (Headers
                  (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                  NoContent)))
-> (Maybe Text
    -> MultipartData Mem
    -> Handler
         (Headers
            (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
            NoContent))
   :<|> ((Maybe Text -> Handler (MarkupM ()))
         :<|> (MultipartData Mem
               -> Handler
                    (Headers
                       (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                       NoContent)))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> m (MarkupM ())
loginFormRoute Env
env
    (Maybe Text -> Handler (MarkupM ()))
-> (MultipartData Mem
    -> Handler
         (Headers
            (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
            NoContent))
-> (Maybe Text -> Handler (MarkupM ()))
   :<|> (MultipartData Mem
         -> Handler
              (Headers
                 (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
                 NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> MultipartData Mem
-> Handler
     (Headers
        (Header "Set-Cookie" Text : Header "Location" Text : NoIx)
        NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> MultipartData tag -> m a
submitLoginRoute Env
env

fallbackRoute :: Handler a
fallbackRoute :: forall a. Handler a
fallbackRoute =
  do
    ServerError -> Handler a
forall a. ServerError -> Handler a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError
    (ServerError -> Handler a) -> ServerError -> Handler a
forall a b. (a -> b) -> a -> b
$ ServerError
      { errHTTPCode :: Int
errHTTPCode = Int
302,
        errReasonPhrase :: String
errReasonPhrase = String
"Found",
        errBody :: ByteString
errBody = ByteString
"",
        errHeaders :: [Header]
errHeaders = [(HeaderName
"Location", Origin
"/songs")]
      }

wikimusicSSRServant :: Proxy WikiMusicSSRServant
wikimusicSSRServant :: Proxy WikiMusicSSRServant
wikimusicSSRServant = Proxy WikiMusicSSRServant
forall {k} (t :: k). Proxy t
Proxy

myCors :: CorsConfig -> Middleware
myCors :: CorsConfig -> Application -> Application
myCors CorsConfig
cfg = (Request -> Maybe CorsResourcePolicy) -> Application -> Application
cors (Maybe CorsResourcePolicy -> Request -> Maybe CorsResourcePolicy
forall a b. a -> b -> a
const (Maybe CorsResourcePolicy -> Request -> Maybe CorsResourcePolicy)
-> Maybe CorsResourcePolicy -> Request -> Maybe CorsResourcePolicy
forall a b. (a -> b) -> a -> b
$ CorsResourcePolicy -> Maybe CorsResourcePolicy
forall a. a -> Maybe a
Just CorsResourcePolicy
policy)
  where
    policy :: CorsResourcePolicy
policy =
      CorsResourcePolicy
        { corsOrigins :: Maybe ([Origin], Bool)
corsOrigins = ([Origin], Bool) -> Maybe ([Origin], Bool)
forall a. a -> Maybe a
Just ((Text -> Origin) -> [Text] -> [Origin]
forall a b. (a -> b) -> [a] -> [b]
map (String -> Origin
forall a. IsString a => String -> a
fromString (String -> Origin) -> (Text -> String) -> Text -> Origin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack) (CorsConfig
cfg CorsConfig -> Optic' A_Lens NoIx CorsConfig [Text] -> [Text]
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx CorsConfig [Text]
#origins), Bool
True),
          corsMethods :: [Origin]
corsMethods = (Text -> Origin) -> [Text] -> [Origin]
forall a b. (a -> b) -> [a] -> [b]
map (String -> Origin
forall a. IsString a => String -> a
fromString (String -> Origin) -> (Text -> String) -> Text -> Origin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack) (CorsConfig
cfg CorsConfig -> Optic' A_Lens NoIx CorsConfig [Text] -> [Text]
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx CorsConfig [Text]
#methods),
          corsRequestHeaders :: [HeaderName]
corsRequestHeaders = (Text -> HeaderName) -> [Text] -> [HeaderName]
forall a b. (a -> b) -> [a] -> [b]
map (String -> HeaderName
forall a. IsString a => String -> a
fromString (String -> HeaderName) -> (Text -> String) -> Text -> HeaderName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack) (CorsConfig
cfg CorsConfig -> Optic' A_Lens NoIx CorsConfig [Text] -> [Text]
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx CorsConfig [Text]
#requestHeaders),
          corsExposedHeaders :: Maybe [HeaderName]
corsExposedHeaders =
            [HeaderName] -> Maybe [HeaderName]
forall a. a -> Maybe a
Just
              [ HeaderName
"content-type",
                HeaderName
"date",
                HeaderName
"content-length",
                HeaderName
"access-control-allow-origin",
                HeaderName
"access-control-allow-methods",
                HeaderName
"access-control-allow-headers",
                HeaderName
"access-control-request-method",
                HeaderName
"access-control-request-headers"
              ],
          corsMaxAge :: Maybe Int
corsMaxAge = Maybe Int
forall a. Maybe a
Nothing,
          corsVaryOrigin :: Bool
corsVaryOrigin = Bool
False,
          corsRequireOrigin :: Bool
corsRequireOrigin = Bool
False,
          corsIgnoreFailures :: Bool
corsIgnoreFailures = Bool
False
        }