-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Embed a directory of static files in your Servant server
--   
--   Please see <a>README.md</a>.
@package servant-static-th
@version 0.2.2.0


-- | Read a directory and the contents of all the files in it as a
--   <a>FileTree</a>.
module Servant.Static.TH.Internal.FileTree

-- | This tree structure represents the directory structure on disk.
data FileTree

-- | A file with it's <a>FilePath</a> and contents as a <a>ByteString</a>.
FileTreeFile :: FilePath -> ByteString -> FileTree

-- | A directory with it's <a>FilePath</a> and the files under it.
FileTreeDir :: FilePath -> NonEmpty FileTree -> FileTree

-- | This is a simple version of <a>FileTree</a>, just used for tagging a
--   given <a>FilePath</a> as a directory or a file.
data FileType
FileTypeFile :: FilePath -> FileType
FileTypeDir :: FilePath -> FileType

-- | Get the <a>FileType</a> for a given <a>FilePath</a>. Calls <a>fail</a>
--   if it is not a file or a directory.
getFileType :: FilePath -> IO FileType

-- | Convert a <a>FileType</a> to a <a>FileTree</a>. Return <a>Nothing</a>
--   if the input <a>FileType</a> is <a>FileTypeDir</a>, and that directory
--   is empty.
fileTypeToFileTree :: FileType -> IO (Maybe FileTree)

-- | Convert an input directory <a>FilePath</a> to a <a>FileTree</a>. Fails
--   if the input directory <a>FilePath</a> is not a directory.
getFileTree :: FilePath -> IO [FileTree]

-- | Just like <a>getFileTree</a>, but returns an error with <a>fail</a> if
--   the input directory is empty.
getFileTreeIgnoreEmpty :: FilePath -> IO (NonEmpty FileTree)
instance GHC.Show.Show Servant.Static.TH.Internal.FileTree.FileType
instance GHC.Read.Read Servant.Static.TH.Internal.FileTree.FileType
instance GHC.Classes.Eq Servant.Static.TH.Internal.FileTree.FileType
instance GHC.Show.Show Servant.Static.TH.Internal.FileTree.FileTree
instance GHC.Read.Read Servant.Static.TH.Internal.FileTree.FileTree
instance GHC.Classes.Eq Servant.Static.TH.Internal.FileTree.FileTree


-- | Utilities functions for use in this package.
module Servant.Static.TH.Internal.Util

-- | Remove a leading period from a <a>String</a>.
--   
--   <pre>
--   &gt;&gt;&gt; removeLeadingPeriod ".jpg"
--   "jpg"
--   </pre>
--   
--   Just return the <a>String</a> if it doesn't start with a period:
--   
--   <pre>
--   &gt;&gt;&gt; removeLeadingPeriod "hello"
--   "hello"
--   </pre>
--   
--   Return an empty string if the only character in the string is a
--   period:
--   
--   <pre>
--   &gt;&gt;&gt; removeLeadingPeriod "."
--   ""
--   </pre>
--   
--   Remove at most one period:
--   
--   <pre>
--   &gt;&gt;&gt; removeLeadingPeriod "..bye"
--   ".bye"
--   </pre>
removeLeadingPeriod :: String -> String

-- | Return an extension for a <a>FilePath</a>. Just like
--   <a>takeExtension</a>, but doesn't return the leading period.
--   
--   <pre>
--   &gt;&gt;&gt; getExtension "/some/file.html"
--   "html"
--   </pre>
--   
--   Empty string is returned for files with no extension:
--   
--   <pre>
--   &gt;&gt;&gt; getExtension "file"
--   ""
--   </pre>
getExtension :: FilePath -> FilePath


-- | This module exports functions and datatypes for using many different
--   mime types.
module Servant.Static.TH.Internal.Mime

-- | Hold <a>Type</a>s and functions work working with a given file type,
--   like <tt>html</tt> or <tt>js</tt>.
--   
--   You can find examples of <a>MimeTypeInfo</a> in the function
--   <a>extensionMimeTypeMap</a>.
data MimeTypeInfo
MimeTypeInfo :: Q Type -> Q Type -> (ByteString -> Q Exp) -> MimeTypeInfo

-- | A <tt><a>Q</a> <a>Type</a></tt> representing a type to use for the
--   content type of a Servant API. For instance, HTML files will use
--   something like <tt>[t|<a>HTML</a>|]</tt>, while Javascript files will
--   use something like <tt>[t|<a>JS</a>|]</tt>.
[mimeTypeInfoContentType] :: MimeTypeInfo -> Q Type

-- | A <tt><a>Q</a> <a>Type</a></tt> representing the type to use for the
--   return vale of a Servant API. For instance, HTML files will use
--   something like <tt>[t|<a>Html</a>|]</tt>, while JavascriptFiles will
--   use something like <tt>[t|<a>ByteString</a>|]</tt>.
[mimeTypeInfoRespType] :: MimeTypeInfo -> Q Type

-- | A function that turns a <a>ByteString</a> into an <a>Exp</a>. For an
--   example, look at <a>htmlToExp</a> and <tt>byteStringtoExp</tt>.
[mimeTypeInfoToExpression] :: MimeTypeInfo -> ByteString -> Q Exp
stringToBs :: String -> ByteString
byteStringToExp :: ByteString -> Q Exp
utf8ByteStringToExp :: ByteString -> Q Exp
htmlToExp :: ByteString -> Q Exp

-- | A mapping from an extension like <tt>html</tt> or <tt>js</tt> to a
--   <a>MimeTypeInfo</a> for that extension.
extensionMimeTypeMap :: Map String MimeTypeInfo

-- | Just like <a>extensionToMimeTypeInfo</a>, but throw an error using
--   <a>fail</a> if the extension for the given <a>FilePath</a> is not
--   found.
extensionToMimeTypeInfoEx :: FilePath -> Q MimeTypeInfo

-- | Lookup the <a>MimeTypeInfo</a> for a given <a>FilePath</a> (that has
--   an extension like <tt>.html</tt> or <tt>.js</tt>). Returns
--   <a>Nothing</a> if the <a>MimeTypeInfo</a> for the given extension is
--   not found.
extensionToMimeTypeInfo :: FilePath -> Maybe MimeTypeInfo
data CSS
data GIF
data JPEG

data ICO
data JS
data PNG
data SVG
data TXT

data EOT

data TTF

data WOFF

data WOFF2

-- | JSON file
data JSON

-- | XML file
data XML

-- | GEXF file (xml for graph application)
data GEXF
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.GEXF
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.GEXF Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.XML
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.XML Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.JSON
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.JSON Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.WOFF2
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.WOFF2 Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.WOFF
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.WOFF Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.TTF
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.TTF Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.EOT
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.EOT Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.TXT
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.TXT Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.SVG
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.SVG Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.PNG
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.PNG Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.JS
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.JS Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.ICO
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.ICO Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.JPEG
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.JPEG Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.GIF
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.GIF Data.ByteString.Internal.ByteString
instance Servant.API.ContentTypes.Accept Servant.Static.TH.Internal.Mime.CSS
instance Servant.API.ContentTypes.MimeRender Servant.Static.TH.Internal.Mime.CSS Data.ByteString.Internal.ByteString

module Servant.Static.TH.Internal.Server
combineWithExp :: Q Exp -> Q Exp -> Q Exp -> Q Exp
combineWithServantOr :: NonEmpty (Q Exp) -> Q Exp
fileTreeToServer :: FileTree -> Q Exp

-- | Take a template directory argument as a <a>FilePath</a> and create a
--   <a>ServerT</a> function that serves the files under the directory.
--   Empty directories will be ignored.
--   
--   Note that the file contents will be embedded in the function. They
--   will not be served dynamically at runtime. This makes it easy to
--   create a Haskell binary for a website with all static files completely
--   baked-in.
--   
--   For example, assume the following directory structure and file
--   contents:
--   
--   <pre>
--   $ tree dir/
--   dir/
--   ├── js
--   │   └── test.js
--   └── index.html
--   </pre>
--   
--   <pre>
--   $ cat dir/index.html
--   &lt;p&gt;Hello World&lt;/p&gt;
--   $ cat dir/js/test.js
--   console.log("hello world");
--   </pre>
--   
--   <a>createServerExp</a> is used like the following:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   type FrontEndAPI = $(<a>createApiType</a> "dir")
--   
--   frontEndServer :: <a>Applicative</a> m =&gt; <a>ServerT</a> FrontEndAPI m
--   frontEndServer = $(<a>createServerExp</a> "dir")
--   </pre>
--   
--   At compile time, this expands to something like the following. This
--   has been slightly simplified to make it easier to understand:
--   
--   <pre>
--   type FrontEndAPI =
--          "js" <a>:&gt;</a> "test.js" <a>:&gt;</a> <a>Get</a> '[<a>JS</a>] <a>ByteString</a>
--     <a>:&lt;|&gt;</a> "index.html" <a>:&gt;</a> <a>Get</a> '[<a>HTML</a>] <a>Html</a>
--   
--   frontEndServer :: <a>Applicative</a> m =&gt; <a>ServerT</a> FrontEndAPI m
--   frontEndServer =
--          <a>pure</a> "console.log(\"hello world\");"
--     <a>:&lt;|&gt;</a> <a>pure</a> "&lt;p&gt;Hello World&lt;/p&gt;"
--   </pre>
createServerExp :: FilePath -> Q Exp

-- | This is similar to <a>createServerExp</a>, but it creates the whole
--   function declaration.
--   
--   Given the following code:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   $(<a>createServerDec</a> "FrontAPI" "frontServer" "dir")
--   </pre>
--   
--   You can think of it as expanding to the following:
--   
--   <pre>
--   frontServer :: <a>Applicative</a> m =&gt; <a>ServerT</a> FrontAPI m
--   frontServer = $(<a>createServerExp</a> "dir")
--   </pre>
createServerDec :: String -> String -> FilePath -> Q [Dec]

module Servant.Static.TH.Internal.Api
fileTreeToApiType :: FileTree -> Q Type

-- | Given a list of <tt><a>Q</a> <a>Type</a></tt>, combine them with
--   Servant's '(:<a>|</a>)' function and return the resulting <tt><a>Q</a>
--   <a>Type</a></tt>.
combineWithServantOrT :: NonEmpty (Q Type) -> Q Type
combineWithType :: Q Type -> Q Type -> Q Type -> Q Type

-- | Take a template directory argument as a <a>FilePath</a> and create a
--   Servant type representing the files in the directory. Empty
--   directories will be ignored.
--   
--   For example, assume the following directory structure:
--   
--   <pre>
--   $ tree dir/
--   dir/
--   ├── js
--   │   └── test.js
--   └── index.html
--   </pre>
--   
--   <a>createApiType</a> is used like the following:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   type FrontEndAPI = $(<a>createApiType</a> "dir")
--   </pre>
--   
--   At compile time, it will expand to the following:
--   
--   <pre>
--   type FrontEndAPI =
--          "js" <a>:&gt;</a> "test.js" <a>:&gt;</a> <a>Get</a> '[<a>JS</a>] <a>ByteString</a>
--     <a>:&lt;|&gt;</a> "index.html" <a>:&gt;</a> <a>Get</a> '[<a>HTML</a>] <a>Html</a>
--   </pre>
createApiType :: FilePath -> Q Type

-- | This is similar to <a>createApiType</a>, but it creates the whole type
--   synonym declaration.
--   
--   Given the following code:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   $(<a>createApiDec</a> "FrontAPI" "dir")
--   </pre>
--   
--   You can think of it as expanding to the following:
--   
--   <pre>
--   type FrontAPI = $(<a>createApiType</a> "dir")
--   </pre>
createApiDec :: String -> FilePath -> Q [Dec]

module Servant.Static.TH.Internal


-- | This module provides the <a>createApiAndServerDecs</a> function. At
--   compile time, it will read all the files under a specified directory,
--   embed their contents, create a Servant "API" type synonym representing
--   their directory layout, and create a <tt>ServerT</tt> function for
--   serving their contents statically.
--   
--   Let's assume that we have a directory called <tt>"dir"</tt> in the
--   root of our Haskell web API that looks like this:
--   
--   <pre>
--   $ tree dir/
--   dir/
--   ├── js
--   │   └── test.js
--   └── hello.html
--   </pre>
--   
--   Here's the contents of <tt>"hello.html"</tt> and
--   <tt>"js/test.js"</tt>:
--   
--   <pre>
--   $ cat dir/index.html
--   &lt;p&gt;Hello World&lt;/p&gt;
--   $ cat dir/js/test.js
--   console.log("hello world");
--   </pre>
--   
--   The <a>createApiAndServerDecs</a> function can be used like the
--   following:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   import <a>Data.Proxy</a> (<a>Proxy</a>(<a>Proxy</a>))
--   import <a>Network.Wai</a> (<a>Application</a>)
--   import <a>Network.Wai.Handler.Warp</a> (<a>run</a>)
--   import <a>Servant.Server</a> (<a>serve</a>)
--   import <a>Servant.Static.TH</a> (<a>createApiAndServerDecs</a>)
--   
--   $(createApiAndServerDecs "FrontEndApi" "frontEndServer" "dir")
--   
--   app :: <a>Application</a>
--   app = <a>serve</a> (<a>Proxy</a> :: <a>Proxy</a> FrontEndApi) frontEndServer
--   
--   main :: IO ()
--   main = <a>run</a> 8080 app
--   </pre>
--   
--   <a>createApiAndServerDecs</a> will expand to something like the
--   following at compile time:
--   
--   <pre>
--   type FrontEndAPI =
--          "js" <a>:&gt;</a> "test.js" <a>:&gt;</a> <a>Get</a> '[<a>JS</a>] <a>ByteString</a>
--     <tt>:&lt;|&gt;</tt> "index.html" <a>:&gt;</a> <a>Get</a> '[<a>HTML</a>] <a>Html</a>
--   
--   frontEndServer :: <a>Applicative</a> m =&gt; <a>ServerT</a> FrontEndAPI m
--   frontEndServer =
--          <a>pure</a> "console.log(\"hello world\");"
--     <tt>:&lt;|&gt;</tt> <a>pure</a> "&lt;p&gt;Hello World&lt;/p&gt;"
--   </pre>
--   
--   If this WAI application is running, it is possible to use
--   <tt>curl</tt> to access the server:
--   
--   <pre>
--   $ curl localhost:8080/hello.html
--   &lt;p&gt;Hello World&lt;/p&gt;
--   $ curl localhost:8080/js/test.js
--   console.log("hello world");
--   </pre>
--   
--   This <a>createApiAndServerDecs</a> function is convenient to use when
--   you want to make a Servant application easy to deploy. All the static
--   frontend files are bundled into the Haskell binary at compile-time, so
--   all you need to do is deploy the Haskell binary. This works well for
--   low-traffic websites like prototypes and internal applications.
--   
--   This shouldn't be used for high-traffic websites. Instead, you should
--   serve your static files from something like Apache, nginx, or a CDN.
module Servant.Static.TH

-- | Take a template directory argument as a <a>FilePath</a> and create a
--   Servant type representing the files in the directory. Empty
--   directories will be ignored.
--   
--   For example, assume the following directory structure:
--   
--   <pre>
--   $ tree dir/
--   dir/
--   ├── js
--   │   └── test.js
--   └── index.html
--   </pre>
--   
--   <a>createApiType</a> is used like the following:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   type FrontEndAPI = $(<a>createApiType</a> "dir")
--   </pre>
--   
--   At compile time, it will expand to the following:
--   
--   <pre>
--   type FrontEndAPI =
--          "js" <a>:&gt;</a> "test.js" <a>:&gt;</a> <a>Get</a> '[<a>JS</a>] <a>ByteString</a>
--     <a>:&lt;|&gt;</a> "index.html" <a>:&gt;</a> <a>Get</a> '[<a>HTML</a>] <a>Html</a>
--   </pre>
createApiType :: FilePath -> Q Type

-- | This is similar to <a>createApiType</a>, but it creates the whole type
--   synonym declaration.
--   
--   Given the following code:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   $(<a>createApiDec</a> "FrontAPI" "dir")
--   </pre>
--   
--   You can think of it as expanding to the following:
--   
--   <pre>
--   type FrontAPI = $(<a>createApiType</a> "dir")
--   </pre>
createApiDec :: String -> FilePath -> Q [Dec]

-- | Take a template directory argument as a <a>FilePath</a> and create a
--   <a>ServerT</a> function that serves the files under the directory.
--   Empty directories will be ignored.
--   
--   Note that the file contents will be embedded in the function. They
--   will not be served dynamically at runtime. This makes it easy to
--   create a Haskell binary for a website with all static files completely
--   baked-in.
--   
--   For example, assume the following directory structure and file
--   contents:
--   
--   <pre>
--   $ tree dir/
--   dir/
--   ├── js
--   │   └── test.js
--   └── index.html
--   </pre>
--   
--   <pre>
--   $ cat dir/index.html
--   &lt;p&gt;Hello World&lt;/p&gt;
--   $ cat dir/js/test.js
--   console.log("hello world");
--   </pre>
--   
--   <a>createServerExp</a> is used like the following:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   type FrontEndAPI = $(<a>createApiType</a> "dir")
--   
--   frontEndServer :: <a>Applicative</a> m =&gt; <a>ServerT</a> FrontEndAPI m
--   frontEndServer = $(<a>createServerExp</a> "dir")
--   </pre>
--   
--   At compile time, this expands to something like the following. This
--   has been slightly simplified to make it easier to understand:
--   
--   <pre>
--   type FrontEndAPI =
--          "js" <a>:&gt;</a> "test.js" <a>:&gt;</a> <a>Get</a> '[<a>JS</a>] <a>ByteString</a>
--     <a>:&lt;|&gt;</a> "index.html" <a>:&gt;</a> <a>Get</a> '[<a>HTML</a>] <a>Html</a>
--   
--   frontEndServer :: <a>Applicative</a> m =&gt; <a>ServerT</a> FrontEndAPI m
--   frontEndServer =
--          <a>pure</a> "console.log(\"hello world\");"
--     <a>:&lt;|&gt;</a> <a>pure</a> "&lt;p&gt;Hello World&lt;/p&gt;"
--   </pre>
createServerExp :: FilePath -> Q Exp

-- | This is similar to <a>createServerExp</a>, but it creates the whole
--   function declaration.
--   
--   Given the following code:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   $(<a>createServerDec</a> "FrontAPI" "frontServer" "dir")
--   </pre>
--   
--   You can think of it as expanding to the following:
--   
--   <pre>
--   frontServer :: <a>Applicative</a> m =&gt; <a>ServerT</a> FrontAPI m
--   frontServer = $(<a>createServerExp</a> "dir")
--   </pre>
createServerDec :: String -> String -> FilePath -> Q [Dec]

-- | This is a combination of <a>createApiDec</a> and
--   <a>createServerDec</a>. This function is the one most users should
--   use.
--   
--   Given the following code:
--   
--   <pre>
--   {-# LANGUAGE DataKinds #-}
--   {-# LANGUAGE TemplateHaskell #-}
--   
--   $(<a>createApiAndServerDecs</a> "FrontAPI" "frontServer" "dir")
--   </pre>
--   
--   You can think of it as expanding to the following:
--   
--   <pre>
--   $(<a>createApiDec</a> "FrontAPI" "dir")
--   
--   $(<a>createServerDec</a> "FrontAPI" "frontServer" "dir")
--   </pre>
createApiAndServerDecs :: String -> String -> FilePath -> Q [Dec]
data CSS

data EOT

-- | GEXF file (xml for graph application)
data GEXF
data GIF
data HTML
type Html = Markup

data ICO
data JPEG
data JS

-- | JSON file
data JSON
data PNG
data SVG

data TTF
data TXT

data WOFF

data WOFF2

-- | XML file
data XML

-- | This is the directory <tt>"frontend/dist"</tt>.
frontEndTemplateDir :: FilePath

-- | This is the <a>String</a> <tt>"FrontEnd"</tt>.
frontEndApiName :: String

-- | This is the <a>String</a> <tt>"frontEndServer"</tt>.
frontEndServerName :: String

-- | This is the same as <tt><a>createApiType</a>
--   <a>frontEndTemplateDir</a></tt>.
createApiFrontEndType :: Q Type

-- | This is the same as <tt><a>createApiDec</a> <a>frontEndApiName</a>
--   <a>frontEndTemplateDir</a></tt>.
createApiFrontEndDec :: Q [Dec]

-- | This is the same as <tt><a>createServerExp</a>
--   <a>frontEndTemplateDir</a></tt>.
createServerFrontEndExp :: Q Exp

-- | This is the same as <tt><a>createServerDec</a> <a>frontEndApiName</a>
--   <a>frontEndServerName</a> <a>frontEndTemplateDir</a></tt>.
createServerFrontEndDec :: Q [Dec]

-- | This is the same as <tt><a>createApiAndServerDecs</a>
--   <a>frontEndApiName</a> <a>frontEndServerName</a>
--   <a>frontEndTemplateDir</a></tt>.
createApiAndServerFrontEndDecs :: Q [Dec]
