{-# LANGUAGE OverloadedLabels #-}

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

import Network.HTTP.Client (newManager)
import Network.HTTP.Client.TLS (tlsManagerSettings)
import Network.Wai
import Network.Wai.Logger (ApacheLogger)
import Network.Wai.Middleware.Cors
import Network.Wai.Middleware.Prometheus qualified as P
import Network.Wai.Middleware.RequestLogger
import Principium
import Servant
import Servant.Client
import WikiMusic.SSR.Backend.Rest ()
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.Servant.Utilities
import WikiMusic.SSR.View.Html ()

newClientEnv :: (MonadIO m) => AppConfig -> m ClientEnv
newClientEnv :: forall (m :: * -> *). MonadIO m => AppConfig -> m ClientEnv
newClientEnv AppConfig
cfg = 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
        { $sel:baseUrlScheme:BaseUrl :: Scheme
baseUrlScheme = if (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 ApiConfig ApiConfig
#api Optic A_Lens NoIx AppConfig AppConfig ApiConfig ApiConfig
-> Optic A_Lens NoIx ApiConfig ApiConfig 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 A_Lens NoIx ApiConfig ApiConfig Text Text
#protocol) Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"https" then Scheme
Https else Scheme
Http,
          $sel:baseUrlHost:BaseUrl :: String
baseUrlHost = Text -> String
unpackText (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ 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 ApiConfig ApiConfig
#api Optic A_Lens NoIx AppConfig AppConfig ApiConfig ApiConfig
-> Optic A_Lens NoIx ApiConfig ApiConfig 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 A_Lens NoIx ApiConfig ApiConfig Text Text
#host,
          $sel:baseUrlPort:BaseUrl :: Int
baseUrlPort = AppConfig
cfg AppConfig -> Optic' A_Lens NoIx AppConfig Int -> Int
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic A_Lens NoIx AppConfig AppConfig ApiConfig ApiConfig
#api Optic A_Lens NoIx AppConfig AppConfig ApiConfig ApiConfig
-> Optic A_Lens NoIx ApiConfig ApiConfig Int Int
-> Optic' A_Lens NoIx AppConfig Int
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 A_Lens NoIx ApiConfig ApiConfig Int Int
#port,
          $sel:baseUrlPath:BaseUrl :: String
baseUrlPath = String
""
        }
    clientEnv :: Manager -> Maybe (TVar CookieJar) -> ClientEnv
clientEnv Manager
manager Maybe (TVar CookieJar)
cookieJar =
      ClientEnv
        { $sel:manager:ClientEnv :: Manager
manager = Manager
manager,
          $sel:baseUrl:ClientEnv :: BaseUrl
baseUrl = BaseUrl
baseUrl',
          $sel:cookieJar:ClientEnv :: Maybe (TVar CookieJar)
cookieJar = Maybe (TVar CookieJar)
cookieJar,
          $sel:makeClientRequest:ClientEnv :: BaseUrl -> Request -> IO Request
makeClientRequest = BaseUrl -> Request -> IO Request
defaultMakeClientRequest,
          $sel:middleware:ClientEnv :: ClientMiddleware
middleware = ClientMiddleware
forall a. a -> a
id
        }

mkApp :: ApacheLogger -> AppConfig -> IO Application
mkApp :: ApacheLogger -> AppConfig -> IO Application
mkApp ApacheLogger
logger' AppConfig
cfg = do
  let apiCfg :: Context NoIx
apiCfg = Context NoIx
EmptyContext

  ZonedTime
now <- IO ZonedTime
getZonedTime
  ClientEnv
clientEnv <- AppConfig -> IO ClientEnv
forall (m :: * -> *). MonadIO m => AppConfig -> m ClientEnv
newClientEnv AppConfig
cfg

  let env :: Env
env =
        Env
          { $sel:logger:Env :: ApacheLogger
logger = ApacheLogger
logger',
            $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:clientEnv:Env :: ClientEnv
clientEnv = ClientEnv
clientEnv
          }
  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
. (if (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) Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"dev" then Application -> Application
logStdoutDev else Application -> Application
logStdout)
    (Application -> Application)
-> (Application -> Application) -> Application -> 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 -> Application)
-> (Application -> Application) -> Application -> Application
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrometheusSettings -> Application -> Application
P.prometheus PrometheusSettings
forall a. Default a => a
P.def
    (Application -> IO Application) -> Application -> IO Application
forall a b. (a -> b) -> a -> b
$ Proxy WikiMusicSSRServant
-> Context NoIx -> Server WikiMusicSSRServant -> Application
forall {k} (api :: k) (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)

artistBaseEntityRoutes :: Env -> Server BaseEntityRoutes
artistBaseEntityRoutes :: Env -> Server BaseEntityRoutes
artistBaseEntityRoutes Env
env =
  Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError m) =>
Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> m (MarkupM ())
artistsRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> Maybe Int
 -> Maybe Int
 -> Maybe Text
 -> 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 -> UUID -> Handler (MarkupM ()))
                                  :<|> ((Maybe Text
                                         -> Maybe Text
                                         -> UUID
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))
                                        :<|> ((MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))
                                              :<|> (((Maybe Text
                                                      -> Maybe Text
                                                      -> UUID
                                                      -> 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
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))))
                                                    :<|> (Maybe Text
                                                          -> UUID
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Location" Text : NoIx)
                                                                  NoContent)))))))))))
-> (Maybe Text
    -> Maybe Text
    -> Maybe Int
    -> Maybe Int
    -> Maybe Text
    -> 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 -> UUID -> Handler (MarkupM ()))
                                       :<|> ((Maybe Text
                                              -> Maybe Text
                                              -> UUID
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent))
                                             :<|> ((MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> (((Maybe Text
                                                           -> Maybe Text
                                                           -> UUID
                                                           -> 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
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))))
                                                         :<|> (Maybe Text
                                                               -> UUID
                                                               -> Handler
                                                                    (Headers
                                                                       (Header "Location" Text
                                                                          : NoIx)
                                                                       NoContent)))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> UUID -> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError 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 -> UUID -> Handler (MarkupM ()))
                            :<|> ((Maybe Text
                                   -> Maybe Text
                                   -> UUID
                                   -> MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                  :<|> ((MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))
                                        :<|> (((Maybe Text
                                                -> Maybe Text
                                                -> UUID
                                                -> 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
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Location" Text : NoIx)
                                                                   NoContent))))
                                              :<|> (Maybe Text
                                                    -> UUID
                                                    -> Handler
                                                         (Headers
                                                            (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 -> UUID -> Handler (MarkupM ()))
                                 :<|> ((Maybe Text
                                        -> Maybe Text
                                        -> UUID
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))
                                       :<|> ((MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent))
                                             :<|> (((Maybe Text
                                                     -> Maybe Text
                                                     -> UUID
                                                     -> 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
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))))
                                                   :<|> (Maybe Text
                                                         -> UUID
                                                         -> Handler
                                                              (Headers
                                                                 (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 -> UUID -> Handler (MarkupM ()))
                      :<|> ((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> ((MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                  :<|> (((Maybe Text
                                          -> Maybe Text
                                          -> UUID
                                          -> 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
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent))))
                                        :<|> (Maybe Text
                                              -> UUID
                                              -> Handler
                                                   (Headers
                                                      (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 -> UUID -> Handler (MarkupM ()))
                           :<|> ((Maybe Text
                                  -> Maybe Text
                                  -> UUID
                                  -> MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                 :<|> ((MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))
                                       :<|> (((Maybe Text
                                               -> Maybe Text
                                               -> UUID
                                               -> 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
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Location" Text : NoIx)
                                                                  NoContent))))
                                             :<|> (Maybe Text
                                                   -> UUID
                                                   -> Handler
                                                        (Headers
                                                           (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 -> UUID -> Handler (MarkupM ()))
                :<|> ((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> ((MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> (((Maybe Text
                                    -> Maybe Text
                                    -> UUID
                                    -> 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
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))))
                                  :<|> (Maybe Text
                                        -> UUID
                                        -> Handler
                                             (Headers
                                                (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 -> UUID -> Handler (MarkupM ()))
                     :<|> ((Maybe Text
                            -> Maybe Text
                            -> UUID
                            -> MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                           :<|> ((MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                 :<|> (((Maybe Text
                                         -> Maybe Text
                                         -> UUID
                                         -> 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
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Location" Text : NoIx)
                                                            NoContent))))
                                       :<|> (Maybe Text
                                             -> UUID
                                             -> Handler
                                                  (Headers
                                                     (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 -> UUID -> Handler (MarkupM ()))
          :<|> ((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> ((MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> (((Maybe Text
                              -> Maybe Text
                              -> UUID
                              -> 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
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))))
                            :<|> (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
          -> UUID
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
               :<|> ((Maybe Text
                      -> Maybe Text
                      -> UUID
                      -> MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                     :<|> ((MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                           :<|> (((Maybe Text
                                   -> Maybe Text
                                   -> UUID
                                   -> 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
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent))))
                                 :<|> (Maybe Text
                                       -> UUID
                                       -> Handler
                                            (Headers
                                               (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 -> UUID -> Handler (MarkupM ()))
    :<|> ((Maybe Text
           -> Maybe Text
           -> UUID
           -> MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> ((MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> (((Maybe Text
                        -> Maybe Text
                        -> UUID
                        -> 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
                                   -> MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
                      :<|> (Maybe Text
                            -> UUID
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
         :<|> ((Maybe Text
                -> Maybe Text
                -> UUID
                -> MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> ((MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                     :<|> (((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> 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
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))))
                           :<|> (Maybe Text
                                 -> UUID
                                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> UUID -> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> UUID -> m (MarkupM ())
artistEditRoute Env
env
    (Maybe Text -> UUID -> Handler (MarkupM ()))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> ((MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> (((Maybe Text
                  -> Maybe Text
                  -> UUID
                  -> 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
                             -> MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
                :<|> (Maybe Text
                      -> UUID
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
-> (Maybe Text -> UUID -> Handler (MarkupM ()))
   :<|> ((Maybe Text
          -> Maybe Text
          -> UUID
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> (((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> 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
                                  -> MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
                     :<|> (Maybe Text
                           -> UUID
                           -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
artistEditFormRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> UUID
 -> MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> (((Maybe Text
            -> Maybe Text
            -> UUID
            -> 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
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
          :<|> (Maybe Text
                -> UUID
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> (((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> 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
                            -> MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
               :<|> (Maybe Text
                     -> UUID
                     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> MultipartData tag -> m a
searchArtistRoute Env
env
    (MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (((Maybe Text
      -> Maybe Text
      -> UUID
      -> 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
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
    :<|> (Maybe Text
          -> UUID
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> (MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> (((Maybe Text
           -> Maybe Text
           -> UUID
           -> 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
                      -> MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
         :<|> (Maybe Text
               -> UUID
               -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
forall a b. a -> b -> a :<|> b
:<|> (Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
createArtistArtworkRoute Env
env (Maybe Text
 -> Maybe Text
 -> UUID
 -> 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
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> 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
               -> MultipartData Mem
               -> Handler (Headers (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
artistArtworkDeleteRoute Env
env (Maybe Text
 -> Maybe Text
 -> UUID
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> 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
         -> MultipartData Mem
         -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
updateArtistArtworkOrderRoute Env
env)
    ((Maybe Text
  -> Maybe Text
  -> UUID
  -> 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
             -> MultipartData Mem
             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
-> (Maybe Text
    -> UUID
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> 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
                -> MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
   :<|> (Maybe Text
         -> UUID
         -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> UUID
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> UUID -> m a
artistDeleteRoute Env
env

genreBaseEntityRoutes :: Env -> Server BaseEntityRoutes
genreBaseEntityRoutes :: Env -> Server BaseEntityRoutes
genreBaseEntityRoutes Env
env =
  Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError m) =>
Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> m (MarkupM ())
genresRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> Maybe Int
 -> Maybe Int
 -> Maybe Text
 -> 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 -> UUID -> Handler (MarkupM ()))
                                  :<|> ((Maybe Text
                                         -> Maybe Text
                                         -> UUID
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))
                                        :<|> ((MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))
                                              :<|> (((Maybe Text
                                                      -> Maybe Text
                                                      -> UUID
                                                      -> 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
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))))
                                                    :<|> (Maybe Text
                                                          -> UUID
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Location" Text : NoIx)
                                                                  NoContent)))))))))))
-> (Maybe Text
    -> Maybe Text
    -> Maybe Int
    -> Maybe Int
    -> Maybe Text
    -> 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 -> UUID -> Handler (MarkupM ()))
                                       :<|> ((Maybe Text
                                              -> Maybe Text
                                              -> UUID
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent))
                                             :<|> ((MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> (((Maybe Text
                                                           -> Maybe Text
                                                           -> UUID
                                                           -> 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
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))))
                                                         :<|> (Maybe Text
                                                               -> UUID
                                                               -> Handler
                                                                    (Headers
                                                                       (Header "Location" Text
                                                                          : NoIx)
                                                                       NoContent)))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> UUID -> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> UUID -> m (MarkupM ())
genreRoute 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 -> UUID -> Handler (MarkupM ()))
                            :<|> ((Maybe Text
                                   -> Maybe Text
                                   -> UUID
                                   -> MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                  :<|> ((MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))
                                        :<|> (((Maybe Text
                                                -> Maybe Text
                                                -> UUID
                                                -> 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
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Location" Text : NoIx)
                                                                   NoContent))))
                                              :<|> (Maybe Text
                                                    -> UUID
                                                    -> Handler
                                                         (Headers
                                                            (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 -> UUID -> Handler (MarkupM ()))
                                 :<|> ((Maybe Text
                                        -> Maybe Text
                                        -> UUID
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))
                                       :<|> ((MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent))
                                             :<|> (((Maybe Text
                                                     -> Maybe Text
                                                     -> UUID
                                                     -> 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
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))))
                                                   :<|> (Maybe Text
                                                         -> UUID
                                                         -> Handler
                                                              (Headers
                                                                 (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
     -> 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 -> UUID -> Handler (MarkupM ()))
                      :<|> ((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> ((MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                  :<|> (((Maybe Text
                                          -> Maybe Text
                                          -> UUID
                                          -> 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
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent))))
                                        :<|> (Maybe Text
                                              -> UUID
                                              -> Handler
                                                   (Headers
                                                      (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 -> UUID -> Handler (MarkupM ()))
                           :<|> ((Maybe Text
                                  -> Maybe Text
                                  -> UUID
                                  -> MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                 :<|> ((MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))
                                       :<|> (((Maybe Text
                                               -> Maybe Text
                                               -> UUID
                                               -> 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
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Location" Text : NoIx)
                                                                  NoContent))))
                                             :<|> (Maybe Text
                                                   -> UUID
                                                   -> Handler
                                                        (Headers
                                                           (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
genreCreateFormRoute 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 -> UUID -> Handler (MarkupM ()))
                :<|> ((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> ((MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> (((Maybe Text
                                    -> Maybe Text
                                    -> UUID
                                    -> 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
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))))
                                  :<|> (Maybe Text
                                        -> UUID
                                        -> Handler
                                             (Headers
                                                (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 -> UUID -> Handler (MarkupM ()))
                     :<|> ((Maybe Text
                            -> Maybe Text
                            -> UUID
                            -> MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                           :<|> ((MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                 :<|> (((Maybe Text
                                         -> Maybe Text
                                         -> UUID
                                         -> 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
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Location" Text : NoIx)
                                                            NoContent))))
                                       :<|> (Maybe Text
                                             -> UUID
                                             -> Handler
                                                  (Headers
                                                     (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
genreLikeRoute 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 -> UUID -> Handler (MarkupM ()))
          :<|> ((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> ((MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> (((Maybe Text
                              -> Maybe Text
                              -> UUID
                              -> 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
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))))
                            :<|> (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
          -> UUID
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
               :<|> ((Maybe Text
                      -> Maybe Text
                      -> UUID
                      -> MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                     :<|> ((MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                           :<|> (((Maybe Text
                                   -> Maybe Text
                                   -> UUID
                                   -> 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
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent))))
                                 :<|> (Maybe Text
                                       -> UUID
                                       -> Handler
                                            (Headers
                                               (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
genreDislikeRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> UUID
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text -> UUID -> Handler (MarkupM ()))
    :<|> ((Maybe Text
           -> Maybe Text
           -> UUID
           -> MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> ((MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> (((Maybe Text
                        -> Maybe Text
                        -> UUID
                        -> 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
                                   -> MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
                      :<|> (Maybe Text
                            -> UUID
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
         :<|> ((Maybe Text
                -> Maybe Text
                -> UUID
                -> MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> ((MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                     :<|> (((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> 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
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))))
                           :<|> (Maybe Text
                                 -> UUID
                                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> UUID -> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> UUID -> m (MarkupM ())
genreEditRoute Env
env
    (Maybe Text -> UUID -> Handler (MarkupM ()))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> ((MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> (((Maybe Text
                  -> Maybe Text
                  -> UUID
                  -> 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
                             -> MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
                :<|> (Maybe Text
                      -> UUID
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
-> (Maybe Text -> UUID -> Handler (MarkupM ()))
   :<|> ((Maybe Text
          -> Maybe Text
          -> UUID
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> (((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> 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
                                  -> MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
                     :<|> (Maybe Text
                           -> UUID
                           -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
genreEditFormRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> UUID
 -> MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> (((Maybe Text
            -> Maybe Text
            -> UUID
            -> 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
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
          :<|> (Maybe Text
                -> UUID
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> (((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> 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
                            -> MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
               :<|> (Maybe Text
                     -> UUID
                     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> MultipartData tag -> m a
searchGenreRoute Env
env
    (MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (((Maybe Text
      -> Maybe Text
      -> UUID
      -> 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
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
    :<|> (Maybe Text
          -> UUID
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> (MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> (((Maybe Text
           -> Maybe Text
           -> UUID
           -> 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
                      -> MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
         :<|> (Maybe Text
               -> UUID
               -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
forall a b. a -> b -> a :<|> b
:<|> (Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
createGenreArtworkRoute Env
env (Maybe Text
 -> Maybe Text
 -> UUID
 -> 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
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> 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
               -> MultipartData Mem
               -> Handler (Headers (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
genreArtworkDeleteRoute Env
env (Maybe Text
 -> Maybe Text
 -> UUID
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> 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
         -> MultipartData Mem
         -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
updateGenreArtworkOrderRoute Env
env)
    ((Maybe Text
  -> Maybe Text
  -> UUID
  -> 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
             -> MultipartData Mem
             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
-> (Maybe Text
    -> UUID
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> 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
                -> MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
   :<|> (Maybe Text
         -> UUID
         -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> UUID
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> UUID -> m a
genreDeleteRoute Env
env

songBaseEntityRoutes :: Env -> Server BaseEntityRoutes
songBaseEntityRoutes :: Env -> Server BaseEntityRoutes
songBaseEntityRoutes Env
env =
  Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError m) =>
Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> m (MarkupM ())
songsRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> Maybe Int
 -> Maybe Int
 -> Maybe Text
 -> 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 -> UUID -> Handler (MarkupM ()))
                                  :<|> ((Maybe Text
                                         -> Maybe Text
                                         -> UUID
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))
                                        :<|> ((MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))
                                              :<|> (((Maybe Text
                                                      -> Maybe Text
                                                      -> UUID
                                                      -> 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
                                                                 -> MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))))
                                                    :<|> (Maybe Text
                                                          -> UUID
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Location" Text : NoIx)
                                                                  NoContent)))))))))))
-> (Maybe Text
    -> Maybe Text
    -> Maybe Int
    -> Maybe Int
    -> Maybe Text
    -> 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 -> UUID -> Handler (MarkupM ()))
                                       :<|> ((Maybe Text
                                              -> Maybe Text
                                              -> UUID
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent))
                                             :<|> ((MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Location" Text : NoIx)
                                                            NoContent))
                                                   :<|> (((Maybe Text
                                                           -> Maybe Text
                                                           -> UUID
                                                           -> 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
                                                                      -> MultipartData Mem
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))))
                                                         :<|> (Maybe Text
                                                               -> UUID
                                                               -> Handler
                                                                    (Headers
                                                                       (Header "Location" Text
                                                                          : NoIx)
                                                                       NoContent)))))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> UUID -> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError 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 "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 -> UUID -> Handler (MarkupM ()))
                            :<|> ((Maybe Text
                                   -> Maybe Text
                                   -> UUID
                                   -> MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                  :<|> ((MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))
                                        :<|> (((Maybe Text
                                                -> Maybe Text
                                                -> UUID
                                                -> 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
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Location" Text : NoIx)
                                                                   NoContent))))
                                              :<|> (Maybe Text
                                                    -> UUID
                                                    -> Handler
                                                         (Headers
                                                            (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 -> UUID -> Handler (MarkupM ()))
                                 :<|> ((Maybe Text
                                        -> Maybe Text
                                        -> UUID
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))
                                       :<|> ((MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent))
                                             :<|> (((Maybe Text
                                                     -> Maybe Text
                                                     -> UUID
                                                     -> 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
                                                                -> MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))))
                                                   :<|> (Maybe Text
                                                         -> UUID
                                                         -> Handler
                                                              (Headers
                                                                 (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 "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 -> UUID -> Handler (MarkupM ()))
                      :<|> ((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> ((MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                  :<|> (((Maybe Text
                                          -> Maybe Text
                                          -> UUID
                                          -> 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
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent))))
                                        :<|> (Maybe Text
                                              -> UUID
                                              -> Handler
                                                   (Headers
                                                      (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 -> UUID -> Handler (MarkupM ()))
                           :<|> ((Maybe Text
                                  -> Maybe Text
                                  -> UUID
                                  -> MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                 :<|> ((MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))
                                       :<|> (((Maybe Text
                                               -> Maybe Text
                                               -> UUID
                                               -> 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
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Location" Text : NoIx)
                                                                  NoContent))))
                                             :<|> (Maybe Text
                                                   -> UUID
                                                   -> Handler
                                                        (Headers
                                                           (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
songCreateFormRoute 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 -> UUID -> Handler (MarkupM ()))
                :<|> ((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> ((MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> (((Maybe Text
                                    -> Maybe Text
                                    -> UUID
                                    -> 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
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))))
                                  :<|> (Maybe Text
                                        -> UUID
                                        -> Handler
                                             (Headers
                                                (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 -> UUID -> Handler (MarkupM ()))
                     :<|> ((Maybe Text
                            -> Maybe Text
                            -> UUID
                            -> MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                           :<|> ((MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                 :<|> (((Maybe Text
                                         -> Maybe Text
                                         -> UUID
                                         -> 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
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Location" Text : NoIx)
                                                            NoContent))))
                                       :<|> (Maybe Text
                                             -> UUID
                                             -> Handler
                                                  (Headers
                                                     (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
songLikeRoute 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 -> UUID -> Handler (MarkupM ()))
          :<|> ((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> ((MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> (((Maybe Text
                              -> Maybe Text
                              -> UUID
                              -> 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
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))))
                            :<|> (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
          -> UUID
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
               :<|> ((Maybe Text
                      -> Maybe Text
                      -> UUID
                      -> MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                     :<|> ((MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                           :<|> (((Maybe Text
                                   -> Maybe Text
                                   -> UUID
                                   -> 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
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent))))
                                 :<|> (Maybe Text
                                       -> UUID
                                       -> Handler
                                            (Headers
                                               (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
songDislikeRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> UUID
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text -> UUID -> Handler (MarkupM ()))
    :<|> ((Maybe Text
           -> Maybe Text
           -> UUID
           -> MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> ((MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> (((Maybe Text
                        -> Maybe Text
                        -> UUID
                        -> 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
                                   -> MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
                      :<|> (Maybe Text
                            -> UUID
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((Maybe Text -> UUID -> Handler (MarkupM ()))
         :<|> ((Maybe Text
                -> Maybe Text
                -> UUID
                -> MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> ((MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                     :<|> (((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> 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
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent))))
                           :<|> (Maybe Text
                                 -> UUID
                                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> UUID -> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> UUID -> m (MarkupM ())
songEditRoute Env
env
    (Maybe Text -> UUID -> Handler (MarkupM ()))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> ((MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> (((Maybe Text
                  -> Maybe Text
                  -> UUID
                  -> 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
                             -> MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
                :<|> (Maybe Text
                      -> UUID
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
-> (Maybe Text -> UUID -> Handler (MarkupM ()))
   :<|> ((Maybe Text
          -> Maybe Text
          -> UUID
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> (((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> 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
                                  -> MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
                     :<|> (Maybe Text
                           -> UUID
                           -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
songEditFormRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> UUID
 -> MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> (((Maybe Text
            -> Maybe Text
            -> UUID
            -> 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
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
          :<|> (Maybe Text
                -> UUID
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> (((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> 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
                            -> MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
               :<|> (Maybe Text
                     -> UUID
                     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> MultipartData tag -> m a
searchSongRoute Env
env
    (MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (((Maybe Text
      -> Maybe Text
      -> UUID
      -> 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
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
    :<|> (Maybe Text
          -> UUID
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> (MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> (((Maybe Text
           -> Maybe Text
           -> UUID
           -> 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
                      -> MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
         :<|> (Maybe Text
               -> UUID
               -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
forall a b. a -> b -> a :<|> b
:<|> (Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
createSongArtworkRoute Env
env (Maybe Text
 -> Maybe Text
 -> UUID
 -> 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
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> 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
               -> MultipartData Mem
               -> Handler (Headers (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
songArtworkDeleteRoute Env
env (Maybe Text
 -> Maybe Text
 -> UUID
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> 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
         -> MultipartData Mem
         -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
updateSongArtworkOrderRoute Env
env)
    ((Maybe Text
  -> Maybe Text
  -> UUID
  -> 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
             -> MultipartData Mem
             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
-> (Maybe Text
    -> UUID
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> 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
                -> MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
   :<|> (Maybe Text
         -> UUID
         -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> UUID
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> UUID -> m a
songDeleteRoute Env
env

preferenceRoutes :: Env -> Server PreferenceRoutes
preferenceRoutes :: Env -> Server PreferenceRoutes
preferenceRoutes Env
env =
  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
    -> 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)))))))
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
    -> 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))))))
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
    -> 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)))))
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
    -> 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))))
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
    -> 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)))
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
    -> 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))
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

loginRoutes :: Env -> Server LoginRoutes
loginRoutes :: Env -> Server LoginRoutes
loginRoutes Env
env =
  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 "Location" Text : NoIx) NoContent))
-> (Maybe Text -> Handler (MarkupM ()))
   :<|> (MultipartData Mem
         -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> MultipartData tag -> m a
submitLoginRoute Env
env

songContentsRoutes :: Env -> Server SongContentsRoutes
songContentsRoutes :: Env -> Server SongContentsRoutes
songContentsRoutes Env
env =
  Env
-> Maybe Text
-> Maybe Text
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> Maybe Text -> Maybe Text -> UUID -> MultipartData tag -> m a
songContentCreateFormRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> UUID
 -> MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> UUID
     -> MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> (UUID
          -> Maybe Text
          -> Maybe Text
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((Maybe Text
          -> Maybe Text
          -> UUID
          -> UUID
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> (UUID
               -> Maybe Text
               -> Maybe Text
               -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> UUID
-> UUID
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) p tag b.
(MonadIO m, MonadError ServerError m) =>
Env
-> Maybe Text
-> Maybe Text
-> p
-> UUID
-> MultipartData tag
-> m b
songContentEditFormRoute Env
env
    (Maybe Text
 -> Maybe Text
 -> UUID
 -> UUID
 -> MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (UUID
    -> Maybe Text
    -> Maybe Text
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (Maybe Text
    -> Maybe Text
    -> UUID
    -> UUID
    -> MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> (UUID
         -> Maybe Text
         -> Maybe Text
         -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> UUID
-> Maybe Text
-> Maybe Text
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) a.
(MonadIO m, MonadError ServerError m) =>
Env -> UUID -> Maybe Text -> Maybe Text -> m a
songContentDeleteRoute Env
env

passwordRoutes :: Env -> Server PasswordRoutes
passwordRoutes :: Env -> Server PasswordRoutes
passwordRoutes Env
env =
  Env -> Maybe Text -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> m (MarkupM ())
requestPasswordResetRoute Env
env
    (Maybe Text -> Handler (MarkupM ()))
-> ((MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
          :<|> (MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
-> (Maybe Text -> Handler (MarkupM ()))
   :<|> ((MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
               :<|> (MultipartData Mem
                     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
forall a b. a -> b -> a :<|> b
:<|> Env
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> MultipartData tag -> m a
doRequestPasswordResetRoute Env
env
    (MultipartData Mem
 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
    :<|> (MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> (MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
   :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
         :<|> (MultipartData Mem
               -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
forall a b. a -> b -> a :<|> b
:<|> Env -> Maybe Text -> Maybe Text -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> Maybe Text -> m (MarkupM ())
doPasswordResetFormRoute Env
env
    (Maybe Text -> Maybe Text -> Handler (MarkupM ()))
-> (MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (Maybe Text -> Maybe Text -> Handler (MarkupM ()))
   :<|> (MultipartData Mem
         -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
forall a b. a -> b -> a :<|> b
:<|> Env
-> MultipartData Mem
-> Handler (Headers (Header "Location" Text : NoIx) NoContent)
forall (m :: * -> *) tag a.
(MonadIO m, MonadError ServerError m) =>
Env -> MultipartData tag -> m a
doPasswordResetRoute Env
env

userRoutes :: Env -> Server UserRoutes
userRoutes :: Env -> Server UserRoutes
userRoutes Env
env =
  Env -> Maybe Text -> Handler (MarkupM ())
forall (m :: * -> *).
MonadIO m =>
Env -> Maybe Text -> m (MarkupM ())
inviteUsersRoute Env
env
    (Maybe Text -> Handler (MarkupM ()))
-> (Maybe Text
    -> MultipartData Mem
    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
-> (Maybe Text -> Handler (MarkupM ()))
   :<|> (Maybe Text
         -> MultipartData Mem
         -> Handler (Headers (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
inviteUsersFormRoute Env
env

staticFilesRoute :: Env -> Server StaticFilesRoute
staticFilesRoute :: Env -> Server StaticFilesRoute
staticFilesRoute Env
env =
  String -> ServerT Raw Handler
String -> Server StaticFilesRoute
forall (m :: * -> *). String -> ServerT Raw m
serveDirectoryFileServer
    (String -> Server StaticFilesRoute)
-> (Text -> String) -> Text -> Server StaticFilesRoute
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
unpackText
    (Text -> Server StaticFilesRoute)
-> Text -> Server StaticFilesRoute
forall a b. (a -> b) -> a -> b
$ (Env
env Env -> Optic' A_Lens NoIx Env Text -> Text
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic A_Lens NoIx Env Env AppConfig AppConfig
#cfg Optic A_Lens NoIx Env Env AppConfig AppConfig
-> Optic
     A_Lens NoIx AppConfig AppConfig WebFrontendConfig WebFrontendConfig
-> Optic A_Lens NoIx Env Env WebFrontendConfig WebFrontendConfig
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
  A_Lens NoIx AppConfig AppConfig WebFrontendConfig WebFrontendConfig
#webFrontend Optic A_Lens NoIx Env Env WebFrontendConfig WebFrontendConfig
-> Optic A_Lens NoIx WebFrontendConfig WebFrontendConfig Text Text
-> Optic' A_Lens NoIx Env 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 A_Lens NoIx WebFrontendConfig WebFrontendConfig Text Text
#staticFileDir)

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
      -> Maybe Text
      -> 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 -> UUID -> Handler (MarkupM ()))
                                         :<|> ((Maybe Text
                                                -> Maybe Text
                                                -> UUID
                                                -> MultipartData Mem
                                                -> Handler
                                                     (Headers
                                                        (Header "Location" Text : NoIx) NoContent))
                                               :<|> ((MultipartData Mem
                                                      -> Handler
                                                           (Headers
                                                              (Header "Location" Text : NoIx)
                                                              NoContent))
                                                     :<|> (((Maybe Text
                                                             -> Maybe Text
                                                             -> UUID
                                                             -> 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
                                                                        -> MultipartData Mem
                                                                        -> Handler
                                                                             (Headers
                                                                                (Header
                                                                                   "Location" Text
                                                                                   : NoIx)
                                                                                NoContent))))
                                                           :<|> (Maybe Text
                                                                 -> UUID
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))))))))))))
    :<|> (((Maybe Text
            -> Maybe Text
            -> Maybe Int
            -> Maybe Int
            -> Maybe Text
            -> 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 -> UUID -> Handler (MarkupM ()))
                                               :<|> ((Maybe Text
                                                      -> Maybe Text
                                                      -> UUID
                                                      -> MultipartData Mem
                                                      -> Handler
                                                           (Headers
                                                              (Header "Location" Text : NoIx)
                                                              NoContent))
                                                     :<|> ((MultipartData Mem
                                                            -> Handler
                                                                 (Headers
                                                                    (Header "Location" Text : NoIx)
                                                                    NoContent))
                                                           :<|> (((Maybe Text
                                                                   -> Maybe Text
                                                                   -> UUID
                                                                   -> 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
                                                                              -> MultipartData Mem
                                                                              -> Handler
                                                                                   (Headers
                                                                                      (Header
                                                                                         "Location"
                                                                                         Text
                                                                                         : NoIx)
                                                                                      NoContent))))
                                                                 :<|> (Maybe Text
                                                                       -> UUID
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Location" Text
                                                                                  : NoIx)
                                                                               NoContent))))))))))))
          :<|> ((((Maybe Text
                   -> Maybe Text
                   -> Maybe Int
                   -> Maybe Int
                   -> Maybe Text
                   -> 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 -> UUID -> Handler (MarkupM ()))
                                                      :<|> ((Maybe Text
                                                             -> Maybe Text
                                                             -> UUID
                                                             -> MultipartData Mem
                                                             -> Handler
                                                                  (Headers
                                                                     (Header "Location" Text : NoIx)
                                                                     NoContent))
                                                            :<|> ((MultipartData Mem
                                                                   -> Handler
                                                                        (Headers
                                                                           (Header "Location" Text
                                                                              : NoIx)
                                                                           NoContent))
                                                                  :<|> (((Maybe Text
                                                                          -> Maybe Text
                                                                          -> UUID
                                                                          -> 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
                                                                                     -> MultipartData
                                                                                          Mem
                                                                                     -> Handler
                                                                                          (Headers
                                                                                             (Header
                                                                                                "Location"
                                                                                                Text
                                                                                                : NoIx)
                                                                                             NoContent))))
                                                                        :<|> (Maybe Text
                                                                              -> UUID
                                                                              -> Handler
                                                                                   (Headers
                                                                                      (Header
                                                                                         "Location"
                                                                                         Text
                                                                                         : NoIx)
                                                                                      NoContent))))))))))))
                 :<|> ((Maybe Text
                        -> Maybe Text
                        -> UUID
                        -> MultipartData Mem
                        -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                       :<|> ((Maybe Text
                              -> Maybe Text
                              -> UUID
                              -> UUID
                              -> MultipartData Mem
                              -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                             :<|> (UUID
                                   -> Maybe Text
                                   -> Maybe Text
                                   -> Handler
                                        (Headers (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 "Location" Text : NoIx) NoContent)))
                            :<|> ((Maybe Text
                                   -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
                                  :<|> (((Maybe Text -> Handler (MarkupM ()))
                                         :<|> ((MultipartData Mem
                                                -> Handler
                                                     (Headers
                                                        (Header "Location" Text : NoIx) NoContent))
                                               :<|> ((Maybe Text
                                                      -> Maybe Text -> Handler (MarkupM ()))
                                                     :<|> (MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Location" Text : NoIx)
                                                                   NoContent)))))
                                        :<|> (((Maybe Text -> Handler (MarkupM ()))
                                               :<|> (Maybe Text
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent)))
                                              :<|> Tagged Handler Application))))))))
-> Handler NoContent
   :<|> (((Maybe Text
           -> Maybe Text
           -> Maybe Int
           -> Maybe Int
           -> Maybe Text
           -> 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 -> UUID -> Handler (MarkupM ()))
                                              :<|> ((Maybe Text
                                                     -> Maybe Text
                                                     -> UUID
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Location" Text : NoIx)
                                                                   NoContent))
                                                          :<|> (((Maybe Text
                                                                  -> Maybe Text
                                                                  -> UUID
                                                                  -> 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
                                                                             -> MultipartData Mem
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Location"
                                                                                        Text
                                                                                        : NoIx)
                                                                                     NoContent))))
                                                                :<|> (Maybe Text
                                                                      -> UUID
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))))))))))))
         :<|> (((Maybe Text
                 -> Maybe Text
                 -> Maybe Int
                 -> Maybe Int
                 -> Maybe Text
                 -> 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 -> UUID -> Handler (MarkupM ()))
                                                    :<|> ((Maybe Text
                                                           -> Maybe Text
                                                           -> UUID
                                                           -> MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Location" Text : NoIx)
                                                                   NoContent))
                                                          :<|> ((MultipartData Mem
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))
                                                                :<|> (((Maybe Text
                                                                        -> Maybe Text
                                                                        -> UUID
                                                                        -> 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
                                                                                   -> MultipartData
                                                                                        Mem
                                                                                   -> Handler
                                                                                        (Headers
                                                                                           (Header
                                                                                              "Location"
                                                                                              Text
                                                                                              : NoIx)
                                                                                           NoContent))))
                                                                      :<|> (Maybe Text
                                                                            -> UUID
                                                                            -> Handler
                                                                                 (Headers
                                                                                    (Header
                                                                                       "Location"
                                                                                       Text
                                                                                       : NoIx)
                                                                                    NoContent))))))))))))
               :<|> ((((Maybe Text
                        -> Maybe Text
                        -> Maybe Int
                        -> Maybe Int
                        -> Maybe Text
                        -> 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
                                                            -> UUID -> Handler (MarkupM ()))
                                                           :<|> ((Maybe Text
                                                                  -> Maybe Text
                                                                  -> UUID
                                                                  -> MultipartData Mem
                                                                  -> Handler
                                                                       (Headers
                                                                          (Header "Location" Text
                                                                             : NoIx)
                                                                          NoContent))
                                                                 :<|> ((MultipartData Mem
                                                                        -> Handler
                                                                             (Headers
                                                                                (Header
                                                                                   "Location" Text
                                                                                   : NoIx)
                                                                                NoContent))
                                                                       :<|> (((Maybe Text
                                                                               -> Maybe Text
                                                                               -> UUID
                                                                               -> 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
                                                                                          -> MultipartData
                                                                                               Mem
                                                                                          -> Handler
                                                                                               (Headers
                                                                                                  (Header
                                                                                                     "Location"
                                                                                                     Text
                                                                                                     : NoIx)
                                                                                                  NoContent))))
                                                                             :<|> (Maybe Text
                                                                                   -> UUID
                                                                                   -> Handler
                                                                                        (Headers
                                                                                           (Header
                                                                                              "Location"
                                                                                              Text
                                                                                              : NoIx)
                                                                                           NoContent))))))))))))
                      :<|> ((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> ((Maybe Text
                                   -> Maybe Text
                                   -> UUID
                                   -> UUID
                                   -> MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                  :<|> (UUID
                                        -> Maybe Text
                                        -> Maybe Text
                                        -> Handler
                                             (Headers (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 "Location" Text : NoIx) NoContent)))
                                 :<|> ((Maybe Text
                                        -> Maybe Text
                                        -> Maybe Int
                                        -> Maybe Text
                                        -> Handler (MarkupM ()))
                                       :<|> (((Maybe Text -> Handler (MarkupM ()))
                                              :<|> ((MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((Maybe Text
                                                           -> Maybe Text -> Handler (MarkupM ()))
                                                          :<|> (MultipartData Mem
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent)))))
                                             :<|> (((Maybe Text -> Handler (MarkupM ()))
                                                    :<|> (Maybe Text
                                                          -> MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Location" Text : NoIx)
                                                                  NoContent)))
                                                   :<|> Tagged Handler Application))))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Server BaseEntityRoutes
artistBaseEntityRoutes Env
env
    ((Maybe Text
  -> Maybe Text
  -> Maybe Int
  -> Maybe Int
  -> Maybe Text
  -> 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 -> UUID -> Handler (MarkupM ()))
                                     :<|> ((Maybe Text
                                            -> Maybe Text
                                            -> UUID
                                            -> MultipartData Mem
                                            -> Handler
                                                 (Headers
                                                    (Header "Location" Text : NoIx) NoContent))
                                           :<|> ((MultipartData Mem
                                                  -> Handler
                                                       (Headers
                                                          (Header "Location" Text : NoIx)
                                                          NoContent))
                                                 :<|> (((Maybe Text
                                                         -> Maybe Text
                                                         -> UUID
                                                         -> 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
                                                                    -> MultipartData Mem
                                                                    -> Handler
                                                                         (Headers
                                                                            (Header "Location" Text
                                                                               : NoIx)
                                                                            NoContent))))
                                                       :<|> (Maybe Text
                                                             -> UUID
                                                             -> Handler
                                                                  (Headers
                                                                     (Header "Location" Text : NoIx)
                                                                     NoContent))))))))))))
-> (((Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> 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 -> UUID -> Handler (MarkupM ()))
                                         :<|> ((Maybe Text
                                                -> Maybe Text
                                                -> UUID
                                                -> MultipartData Mem
                                                -> Handler
                                                     (Headers
                                                        (Header "Location" Text : NoIx) NoContent))
                                               :<|> ((MultipartData Mem
                                                      -> Handler
                                                           (Headers
                                                              (Header "Location" Text : NoIx)
                                                              NoContent))
                                                     :<|> (((Maybe Text
                                                             -> Maybe Text
                                                             -> UUID
                                                             -> 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
                                                                        -> MultipartData Mem
                                                                        -> Handler
                                                                             (Headers
                                                                                (Header
                                                                                   "Location" Text
                                                                                   : NoIx)
                                                                                NoContent))))
                                                           :<|> (Maybe Text
                                                                 -> UUID
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))))))))))))
    :<|> ((((Maybe Text
             -> Maybe Text
             -> Maybe Int
             -> Maybe Int
             -> Maybe Text
             -> 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 -> UUID -> Handler (MarkupM ()))
                                                :<|> ((Maybe Text
                                                       -> Maybe Text
                                                       -> UUID
                                                       -> MultipartData Mem
                                                       -> Handler
                                                            (Headers
                                                               (Header "Location" Text : NoIx)
                                                               NoContent))
                                                      :<|> ((MultipartData Mem
                                                             -> Handler
                                                                  (Headers
                                                                     (Header "Location" Text : NoIx)
                                                                     NoContent))
                                                            :<|> (((Maybe Text
                                                                    -> Maybe Text
                                                                    -> UUID
                                                                    -> 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
                                                                               -> MultipartData Mem
                                                                               -> Handler
                                                                                    (Headers
                                                                                       (Header
                                                                                          "Location"
                                                                                          Text
                                                                                          : NoIx)
                                                                                       NoContent))))
                                                                  :<|> (Maybe Text
                                                                        -> UUID
                                                                        -> Handler
                                                                             (Headers
                                                                                (Header
                                                                                   "Location" Text
                                                                                   : NoIx)
                                                                                NoContent))))))))))))
           :<|> ((Maybe Text
                  -> Maybe Text
                  -> UUID
                  -> MultipartData Mem
                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                 :<|> ((Maybe Text
                        -> Maybe Text
                        -> UUID
                        -> UUID
                        -> MultipartData Mem
                        -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                       :<|> (UUID
                             -> Maybe Text
                             -> Maybe Text
                             -> Handler (Headers (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 "Location" Text : NoIx) NoContent)))
                      :<|> ((Maybe Text
                             -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
                            :<|> (((Maybe Text -> Handler (MarkupM ()))
                                   :<|> ((MultipartData Mem
                                          -> Handler
                                               (Headers (Header "Location" Text : NoIx) NoContent))
                                         :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                                               :<|> (MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent)))))
                                  :<|> (((Maybe Text -> Handler (MarkupM ()))
                                         :<|> (Maybe Text
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent)))
                                        :<|> Tagged Handler Application)))))))
-> ((Maybe Text
     -> Maybe Text
     -> Maybe Int
     -> Maybe Int
     -> Maybe Text
     -> 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 -> UUID -> Handler (MarkupM ()))
                                        :<|> ((Maybe Text
                                               -> Maybe Text
                                               -> UUID
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))
                                              :<|> ((MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> (((Maybe Text
                                                            -> Maybe Text
                                                            -> UUID
                                                            -> 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
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Location" Text
                                                                                  : NoIx)
                                                                               NoContent))))
                                                          :<|> (Maybe Text
                                                                -> UUID
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))))))))))))
   :<|> (((Maybe Text
           -> Maybe Text
           -> Maybe Int
           -> Maybe Int
           -> Maybe Text
           -> 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 -> UUID -> Handler (MarkupM ()))
                                              :<|> ((Maybe Text
                                                     -> Maybe Text
                                                     -> UUID
                                                     -> MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> ((MultipartData Mem
                                                           -> Handler
                                                                (Headers
                                                                   (Header "Location" Text : NoIx)
                                                                   NoContent))
                                                          :<|> (((Maybe Text
                                                                  -> Maybe Text
                                                                  -> UUID
                                                                  -> 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
                                                                             -> MultipartData Mem
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Location"
                                                                                        Text
                                                                                        : NoIx)
                                                                                     NoContent))))
                                                                :<|> (Maybe Text
                                                                      -> UUID
                                                                      -> Handler
                                                                           (Headers
                                                                              (Header
                                                                                 "Location" Text
                                                                                 : NoIx)
                                                                              NoContent))))))))))))
         :<|> ((((Maybe Text
                  -> Maybe Text
                  -> Maybe Int
                  -> Maybe Int
                  -> Maybe Text
                  -> 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 -> UUID -> Handler (MarkupM ()))
                                                     :<|> ((Maybe Text
                                                            -> Maybe Text
                                                            -> UUID
                                                            -> MultipartData Mem
                                                            -> Handler
                                                                 (Headers
                                                                    (Header "Location" Text : NoIx)
                                                                    NoContent))
                                                           :<|> ((MultipartData Mem
                                                                  -> Handler
                                                                       (Headers
                                                                          (Header "Location" Text
                                                                             : NoIx)
                                                                          NoContent))
                                                                 :<|> (((Maybe Text
                                                                         -> Maybe Text
                                                                         -> UUID
                                                                         -> 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
                                                                                    -> MultipartData
                                                                                         Mem
                                                                                    -> Handler
                                                                                         (Headers
                                                                                            (Header
                                                                                               "Location"
                                                                                               Text
                                                                                               : NoIx)
                                                                                            NoContent))))
                                                                       :<|> (Maybe Text
                                                                             -> UUID
                                                                             -> Handler
                                                                                  (Headers
                                                                                     (Header
                                                                                        "Location"
                                                                                        Text
                                                                                        : NoIx)
                                                                                     NoContent))))))))))))
                :<|> ((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> ((Maybe Text
                             -> Maybe Text
                             -> UUID
                             -> UUID
                             -> MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> (UUID
                                  -> Maybe Text
                                  -> Maybe Text
                                  -> Handler (Headers (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 "Location" Text : NoIx) NoContent)))
                           :<|> ((Maybe Text
                                  -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
                                 :<|> (((Maybe Text -> Handler (MarkupM ()))
                                        :<|> ((MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))
                                              :<|> ((Maybe Text
                                                     -> Maybe Text -> Handler (MarkupM ()))
                                                    :<|> (MultipartData Mem
                                                          -> Handler
                                                               (Headers
                                                                  (Header "Location" Text : NoIx)
                                                                  NoContent)))))
                                       :<|> (((Maybe Text -> Handler (MarkupM ()))
                                              :<|> (Maybe Text
                                                    -> MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Location" Text : NoIx)
                                                            NoContent)))
                                             :<|> Tagged Handler Application)))))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Server BaseEntityRoutes
genreBaseEntityRoutes Env
env
    ((Maybe Text
  -> Maybe Text
  -> Maybe Int
  -> Maybe Int
  -> Maybe Text
  -> 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 -> UUID -> Handler (MarkupM ()))
                                     :<|> ((Maybe Text
                                            -> Maybe Text
                                            -> UUID
                                            -> MultipartData Mem
                                            -> Handler
                                                 (Headers
                                                    (Header "Location" Text : NoIx) NoContent))
                                           :<|> ((MultipartData Mem
                                                  -> Handler
                                                       (Headers
                                                          (Header "Location" Text : NoIx)
                                                          NoContent))
                                                 :<|> (((Maybe Text
                                                         -> Maybe Text
                                                         -> UUID
                                                         -> 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
                                                                    -> MultipartData Mem
                                                                    -> Handler
                                                                         (Headers
                                                                            (Header "Location" Text
                                                                               : NoIx)
                                                                            NoContent))))
                                                       :<|> (Maybe Text
                                                             -> UUID
                                                             -> Handler
                                                                  (Headers
                                                                     (Header "Location" Text : NoIx)
                                                                     NoContent))))))))))))
-> ((((Maybe Text
       -> Maybe Text
       -> Maybe Int
       -> Maybe Int
       -> Maybe Text
       -> 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 -> UUID -> Handler (MarkupM ()))
                                          :<|> ((Maybe Text
                                                 -> Maybe Text
                                                 -> UUID
                                                 -> MultipartData Mem
                                                 -> Handler
                                                      (Headers
                                                         (Header "Location" Text : NoIx) NoContent))
                                                :<|> ((MultipartData Mem
                                                       -> Handler
                                                            (Headers
                                                               (Header "Location" Text : NoIx)
                                                               NoContent))
                                                      :<|> (((Maybe Text
                                                              -> Maybe Text
                                                              -> UUID
                                                              -> 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
                                                                         -> MultipartData Mem
                                                                         -> Handler
                                                                              (Headers
                                                                                 (Header
                                                                                    "Location" Text
                                                                                    : NoIx)
                                                                                 NoContent))))
                                                            :<|> (Maybe Text
                                                                  -> UUID
                                                                  -> Handler
                                                                       (Headers
                                                                          (Header "Location" Text
                                                                             : NoIx)
                                                                          NoContent))))))))))))
     :<|> ((Maybe Text
            -> Maybe Text
            -> UUID
            -> MultipartData Mem
            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
           :<|> ((Maybe Text
                  -> Maybe Text
                  -> UUID
                  -> UUID
                  -> MultipartData Mem
                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                 :<|> (UUID
                       -> Maybe Text
                       -> Maybe Text
                       -> Handler (Headers (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 "Location" Text : NoIx) NoContent)))
                :<|> ((Maybe Text
                       -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
                      :<|> (((Maybe Text -> Handler (MarkupM ()))
                             :<|> ((MultipartData Mem
                                    -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                   :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                                         :<|> (MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx)
                                                       NoContent)))))
                            :<|> (((Maybe Text -> Handler (MarkupM ()))
                                   :<|> (Maybe Text
                                         -> MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent)))
                                  :<|> Tagged Handler Application))))))
-> ((Maybe Text
     -> Maybe Text
     -> Maybe Int
     -> Maybe Int
     -> Maybe Text
     -> 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 -> UUID -> Handler (MarkupM ()))
                                        :<|> ((Maybe Text
                                               -> Maybe Text
                                               -> UUID
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))
                                              :<|> ((MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> (((Maybe Text
                                                            -> Maybe Text
                                                            -> UUID
                                                            -> 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
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Location" Text
                                                                                  : NoIx)
                                                                               NoContent))))
                                                          :<|> (Maybe Text
                                                                -> UUID
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))))))))))))
   :<|> ((((Maybe Text
            -> Maybe Text
            -> Maybe Int
            -> Maybe Int
            -> Maybe Text
            -> 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 -> UUID -> Handler (MarkupM ()))
                                               :<|> ((Maybe Text
                                                      -> Maybe Text
                                                      -> UUID
                                                      -> MultipartData Mem
                                                      -> Handler
                                                           (Headers
                                                              (Header "Location" Text : NoIx)
                                                              NoContent))
                                                     :<|> ((MultipartData Mem
                                                            -> Handler
                                                                 (Headers
                                                                    (Header "Location" Text : NoIx)
                                                                    NoContent))
                                                           :<|> (((Maybe Text
                                                                   -> Maybe Text
                                                                   -> UUID
                                                                   -> 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
                                                                              -> MultipartData Mem
                                                                              -> Handler
                                                                                   (Headers
                                                                                      (Header
                                                                                         "Location"
                                                                                         Text
                                                                                         : NoIx)
                                                                                      NoContent))))
                                                                 :<|> (Maybe Text
                                                                       -> UUID
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Location" Text
                                                                                  : NoIx)
                                                                               NoContent))))))))))))
          :<|> ((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> ((Maybe Text
                       -> Maybe Text
                       -> UUID
                       -> UUID
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> (UUID
                            -> Maybe Text
                            -> Maybe Text
                            -> Handler (Headers (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 "Location" Text : NoIx) NoContent)))
                     :<|> ((Maybe Text
                            -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
                           :<|> (((Maybe Text -> Handler (MarkupM ()))
                                  :<|> ((MultipartData Mem
                                         -> Handler
                                              (Headers (Header "Location" Text : NoIx) NoContent))
                                        :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                                              :<|> (MultipartData Mem
                                                    -> Handler
                                                         (Headers
                                                            (Header "Location" Text : NoIx)
                                                            NoContent)))))
                                 :<|> (((Maybe Text -> Handler (MarkupM ()))
                                        :<|> (Maybe Text
                                              -> MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent)))
                                       :<|> Tagged Handler Application))))))
forall a b. a -> b -> a :<|> b
:<|> ( Env -> Server BaseEntityRoutes
songBaseEntityRoutes Env
env
             ((Maybe Text
  -> Maybe Text
  -> Maybe Int
  -> Maybe Int
  -> Maybe Text
  -> 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 -> UUID -> Handler (MarkupM ()))
                                     :<|> ((Maybe Text
                                            -> Maybe Text
                                            -> UUID
                                            -> MultipartData Mem
                                            -> Handler
                                                 (Headers
                                                    (Header "Location" Text : NoIx) NoContent))
                                           :<|> ((MultipartData Mem
                                                  -> Handler
                                                       (Headers
                                                          (Header "Location" Text : NoIx)
                                                          NoContent))
                                                 :<|> (((Maybe Text
                                                         -> Maybe Text
                                                         -> UUID
                                                         -> 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
                                                                    -> MultipartData Mem
                                                                    -> Handler
                                                                         (Headers
                                                                            (Header "Location" Text
                                                                               : NoIx)
                                                                            NoContent))))
                                                       :<|> (Maybe Text
                                                             -> UUID
                                                             -> Handler
                                                                  (Headers
                                                                     (Header "Location" Text : NoIx)
                                                                     NoContent))))))))))))
-> ((Maybe Text
     -> Maybe Text
     -> UUID
     -> MultipartData Mem
     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
    :<|> ((Maybe Text
           -> Maybe Text
           -> UUID
           -> UUID
           -> MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> (UUID
                -> Maybe Text
                -> Maybe Text
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
-> ((Maybe Text
     -> Maybe Text
     -> Maybe Int
     -> Maybe Int
     -> Maybe Text
     -> 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 -> UUID -> Handler (MarkupM ()))
                                        :<|> ((Maybe Text
                                               -> Maybe Text
                                               -> UUID
                                               -> MultipartData Mem
                                               -> Handler
                                                    (Headers
                                                       (Header "Location" Text : NoIx) NoContent))
                                              :<|> ((MultipartData Mem
                                                     -> Handler
                                                          (Headers
                                                             (Header "Location" Text : NoIx)
                                                             NoContent))
                                                    :<|> (((Maybe Text
                                                            -> Maybe Text
                                                            -> UUID
                                                            -> 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
                                                                       -> MultipartData Mem
                                                                       -> Handler
                                                                            (Headers
                                                                               (Header
                                                                                  "Location" Text
                                                                                  : NoIx)
                                                                               NoContent))))
                                                          :<|> (Maybe Text
                                                                -> UUID
                                                                -> Handler
                                                                     (Headers
                                                                        (Header "Location" Text
                                                                           : NoIx)
                                                                        NoContent))))))))))))
   :<|> ((Maybe Text
          -> Maybe Text
          -> UUID
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
         :<|> ((Maybe Text
                -> Maybe Text
                -> UUID
                -> UUID
                -> MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
               :<|> (UUID
                     -> Maybe Text
                     -> Maybe Text
                     -> Handler (Headers (Header "Location" Text : NoIx) NoContent))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Server SongContentsRoutes
songContentsRoutes Env
env
         )
    (((Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> 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 -> UUID -> Handler (MarkupM ()))
                                      :<|> ((Maybe Text
                                             -> Maybe Text
                                             -> UUID
                                             -> MultipartData Mem
                                             -> Handler
                                                  (Headers
                                                     (Header "Location" Text : NoIx) NoContent))
                                            :<|> ((MultipartData Mem
                                                   -> Handler
                                                        (Headers
                                                           (Header "Location" Text : NoIx)
                                                           NoContent))
                                                  :<|> (((Maybe Text
                                                          -> Maybe Text
                                                          -> UUID
                                                          -> 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
                                                                     -> MultipartData Mem
                                                                     -> Handler
                                                                          (Headers
                                                                             (Header "Location" Text
                                                                                : NoIx)
                                                                             NoContent))))
                                                        :<|> (Maybe Text
                                                              -> UUID
                                                              -> Handler
                                                                   (Headers
                                                                      (Header "Location" Text
                                                                         : NoIx)
                                                                      NoContent))))))))))))
 :<|> ((Maybe Text
        -> Maybe Text
        -> UUID
        -> MultipartData Mem
        -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
       :<|> ((Maybe Text
              -> Maybe Text
              -> UUID
              -> UUID
              -> MultipartData Mem
              -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
             :<|> (UUID
                   -> Maybe Text
                   -> Maybe Text
                   -> Handler (Headers (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 "Location" Text : NoIx) NoContent)))
          :<|> ((Maybe Text
                 -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
                :<|> (((Maybe Text -> Handler (MarkupM ()))
                       :<|> ((MultipartData Mem
                              -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                             :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                                   :<|> (MultipartData Mem
                                         -> Handler
                                              (Headers
                                                 (Header "Location" Text : NoIx) NoContent)))))
                      :<|> (((Maybe Text -> Handler (MarkupM ()))
                             :<|> (Maybe Text
                                   -> MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
                            :<|> Tagged Handler Application)))))
-> (((Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> 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 -> UUID -> Handler (MarkupM ()))
                                         :<|> ((Maybe Text
                                                -> Maybe Text
                                                -> UUID
                                                -> MultipartData Mem
                                                -> Handler
                                                     (Headers
                                                        (Header "Location" Text : NoIx) NoContent))
                                               :<|> ((MultipartData Mem
                                                      -> Handler
                                                           (Headers
                                                              (Header "Location" Text : NoIx)
                                                              NoContent))
                                                     :<|> (((Maybe Text
                                                             -> Maybe Text
                                                             -> UUID
                                                             -> 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
                                                                        -> MultipartData Mem
                                                                        -> Handler
                                                                             (Headers
                                                                                (Header
                                                                                   "Location" Text
                                                                                   : NoIx)
                                                                                NoContent))))
                                                           :<|> (Maybe Text
                                                                 -> UUID
                                                                 -> Handler
                                                                      (Headers
                                                                         (Header "Location" Text
                                                                            : NoIx)
                                                                         NoContent))))))))))))
    :<|> ((Maybe Text
           -> Maybe Text
           -> UUID
           -> MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> ((Maybe Text
                 -> Maybe Text
                 -> UUID
                 -> UUID
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> (UUID
                      -> Maybe Text
                      -> Maybe Text
                      -> Handler (Headers (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 "Location" Text : NoIx) NoContent)))
               :<|> ((Maybe Text
                      -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
                     :<|> (((Maybe Text -> Handler (MarkupM ()))
                            :<|> ((MultipartData Mem
                                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                                  :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                                        :<|> (MultipartData Mem
                                              -> Handler
                                                   (Headers
                                                      (Header "Location" Text : NoIx) NoContent)))))
                           :<|> (((Maybe Text -> Handler (MarkupM ()))
                                  :<|> (Maybe Text
                                        -> MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent)))
                                 :<|> Tagged Handler Application)))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Server PreferenceRoutes
preferenceRoutes 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 "Location" Text : NoIx) NoContent)))
    :<|> ((Maybe Text
           -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
          :<|> (((Maybe Text -> Handler (MarkupM ()))
                 :<|> ((MultipartData Mem
                        -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                       :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                             :<|> (MultipartData Mem
                                   -> Handler
                                        (Headers (Header "Location" Text : NoIx) NoContent)))))
                :<|> (((Maybe Text -> Handler (MarkupM ()))
                       :<|> (Maybe Text
                             -> MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
                      :<|> Tagged Handler Application))))
-> ((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 "Location" Text : NoIx) NoContent)))
         :<|> ((Maybe Text
                -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
               :<|> (((Maybe Text -> Handler (MarkupM ()))
                      :<|> ((MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                            :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                                  :<|> (MultipartData Mem
                                        -> Handler
                                             (Headers (Header "Location" Text : NoIx) NoContent)))))
                     :<|> (((Maybe Text -> Handler (MarkupM ()))
                            :<|> (Maybe Text
                                  -> MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
                           :<|> Tagged Handler Application))))
forall a b. a -> b -> a :<|> b
:<|> Env -> Server LoginRoutes
loginRoutes Env
env
    ((Maybe Text -> Handler (MarkupM ()))
 :<|> (MultipartData Mem
       -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> ((Maybe Text
     -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
    :<|> (((Maybe Text -> Handler (MarkupM ()))
           :<|> ((MultipartData Mem
                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                 :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                       :<|> (MultipartData Mem
                             -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
          :<|> (((Maybe Text -> Handler (MarkupM ()))
                 :<|> (Maybe Text
                       -> MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
                :<|> Tagged Handler Application)))
-> ((Maybe Text -> Handler (MarkupM ()))
    :<|> (MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
   :<|> ((Maybe Text
          -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
         :<|> (((Maybe Text -> Handler (MarkupM ()))
                :<|> ((MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                      :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                            :<|> (MultipartData Mem
                                  -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
               :<|> (((Maybe Text -> Handler (MarkupM ()))
                      :<|> (Maybe Text
                            -> MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
                     :<|> Tagged Handler Application)))
forall a b. a -> b -> a :<|> b
:<|> Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Text
-> Handler (MarkupM ())
forall (m :: * -> *).
(MonadIO m, MonadError ServerError m) =>
Env
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Text
-> m (MarkupM ())
errorRoute Env
env
    (Maybe Text
 -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
-> (((Maybe Text -> Handler (MarkupM ()))
     :<|> ((MultipartData Mem
            -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
           :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                 :<|> (MultipartData Mem
                       -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
    :<|> (((Maybe Text -> Handler (MarkupM ()))
           :<|> (Maybe Text
                 -> MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
          :<|> Tagged Handler Application))
-> (Maybe Text
    -> Maybe Text -> Maybe Int -> Maybe Text -> Handler (MarkupM ()))
   :<|> (((Maybe Text -> Handler (MarkupM ()))
          :<|> ((MultipartData Mem
                 -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
                :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                      :<|> (MultipartData Mem
                            -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
         :<|> (((Maybe Text -> Handler (MarkupM ()))
                :<|> (Maybe Text
                      -> MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
               :<|> Tagged Handler Application))
forall a b. a -> b -> a :<|> b
:<|> Env -> Server PasswordRoutes
passwordRoutes Env
env
    ((Maybe Text -> Handler (MarkupM ()))
 :<|> ((MultipartData Mem
        -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
       :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
             :<|> (MultipartData Mem
                   -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
-> (((Maybe Text -> Handler (MarkupM ()))
     :<|> (Maybe Text
           -> MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
    :<|> Tagged Handler Application)
-> ((Maybe Text -> Handler (MarkupM ()))
    :<|> ((MultipartData Mem
           -> Handler (Headers (Header "Location" Text : NoIx) NoContent))
          :<|> ((Maybe Text -> Maybe Text -> Handler (MarkupM ()))
                :<|> (MultipartData Mem
                      -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))))
   :<|> (((Maybe Text -> Handler (MarkupM ()))
          :<|> (Maybe Text
                -> MultipartData Mem
                -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
         :<|> Tagged Handler Application)
forall a b. a -> b -> a :<|> b
:<|> Env -> Server UserRoutes
userRoutes Env
env
    ((Maybe Text -> Handler (MarkupM ()))
 :<|> (Maybe Text
       -> MultipartData Mem
       -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
-> Tagged Handler Application
-> ((Maybe Text -> Handler (MarkupM ()))
    :<|> (Maybe Text
          -> MultipartData Mem
          -> Handler (Headers (Header "Location" Text : NoIx) NoContent)))
   :<|> Tagged Handler Application
forall a b. a -> b -> a :<|> b
:<|> Env -> Server StaticFilesRoute
staticFilesRoute Env
env

fallbackRoute :: Handler a
fallbackRoute :: forall a. Handler a
fallbackRoute =
  ServerResponse -> Handler a
forall (m :: * -> *) a.
(MonadIO m, MonadError ServerError m) =>
ServerResponse -> m a
respondWithHttp
    ServerResponse
httpFound
      { cause = Just "Fallback page!",
        headers =
          [ withLocation "/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 Text -> Origin
forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 (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 Text -> Origin
forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 (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
unpackText) (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
        }