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


-- | Snap: A Haskell Web Framework: project starter executable and glue code library
--   
--   Snap Framework project starter executable and glue code library
@package snap
@version 0.7


-- | This module includes the machinery necessary to use hint to load
--   action code dynamically. It includes a Template Haskell function to
--   gather the necessary compile-time information about code location,
--   compiler arguments, etc, and bind that information into the calls to
--   the dynamic loader.
module Snap.Loader.Devel

-- | This function derives all the information necessary to use the
--   interpreter from the compile-time environment, and compiles it in to
--   the generated code.
--   
--   This could be considered a TH wrapper around a function
--   
--   <pre>
--   loadSnap :: Typeable a =&gt; IO a -&gt; (a -&gt; IO (Snap (), IO ()))
--                          -&gt; [String] -&gt; IO (a, Snap (), IO ())
--   </pre>
--   
--   with a magical implementation. The [String] argument is a list of
--   directories to watch for updates to trigger a reloading. Directories
--   containing code should be automatically picked up by this splice.
--   
--   The generated splice executes the initialiser once, sets up the
--   interpreter for the load function, and returns the initializer's
--   result along with the interpreter's proxy handler and cleanup actions.
--   The behavior of the proxy actions will change to reflect changes in
--   the watched files, reinterpreting the load function as needed and
--   applying it to the initializer result.
--   
--   This will handle reloading the application successfully in most cases.
--   The cases in which it is certain to fail are those involving changing
--   the types of the initializer or the load function, or changing the
--   compiler options required, such as by changing/adding dependencies in
--   the project's .cabal file. In those cases, a full recompile will be
--   needed.
loadSnapTH :: Q Exp -> Name -> [String] -> Q Exp

module Snap.Loader.Prod

-- | This function provides a non-magical type-compatible loader for the
--   one in Snap.Loader.Devel, allowing switching one import to provide
--   production-mode compilation.
--   
--   This could be considered a TH wrapper around a function
--   
--   <pre>
--   loadSnap :: Typeable a =&gt; IO a -&gt; (a -&gt; IO (Snap (), IO ()))
--                          -&gt; [String] -&gt; IO (a, Snap (), IO ())
--   </pre>
--   
--   The third argument is unused, and only present for type-compatibility
--   with Snap.Loader.Devel
loadSnapTH :: Q Exp -> Name -> [String] -> Q Exp


-- | Snaplets allow you to build web applications out of composable parts.
--   This allows you to build self-contained units and glue them together
--   to make your overall application.
--   
--   A snaplet has a few moving parts, some user-defined and some provided
--   by the snaplet API:
--   
--   <ul>
--   <li>each snaplet has its own configuration given to it at
--   startup.</li>
--   <li>each snaplet is given its own directory on the filesystem, from
--   which it reads its configuration and in which it can store files.</li>
--   <li>each snaplet comes with an <a>Initializer</a> which defines how to
--   create an instance of the Snaplet at startup. The initializer decides
--   how to interpret the snaplet configuration, which URLs to handle (and
--   how), sets up the initial snaplet state, tells the snaplet runtime
--   system how to clean the snaplet up, etc.</li>
--   <li>each snaplet contains some user-defined in-memory state; for
--   instance, a snaplet that talks to a database might contain a reference
--   to a connection pool. The snaplet state is an ordinary Haskell record,
--   with a datatype defined by the snaplet author. The initial state
--   record is created during initialization and is available to snaplet
--   <a>Handler</a>s when serving HTTP requests.</li>
--   </ul>
--   
--   NOTE: This documentation is written as a prose tutorial of the
--   snaplets API. Don't be scared by the fact that it's auto-generated and
--   is filled with type signatures. Just keep reading.
module Snap.Snaplet

-- | Snaplet's type parameter <tt>s</tt> here is user-defined and can be
--   any Haskell type. A value of type <tt>Snaplet s</tt> countains a
--   couple of things:
--   
--   <ul>
--   <li>a value of type <tt>s</tt>, called the "user state".</li>
--   <li>some bookkeeping data the framework uses to plug things together,
--   like the snaplet's configuration, the snaplet's root directory on the
--   filesystem, the snaplet's root URL, and so on.</li>
--   </ul>
data Snaplet s

-- | An opaque data type holding internal snaplet configuration data. It is
--   exported publicly because the getOpaqueConfig function in MonadSnaplet
--   makes implementing new instances of MonadSnaplet more convenient.
data SnapletConfig

-- | A lens referencing the opaque SnapletConfig data type held inside
--   Snaplet.
snapletConfig :: Lens (Snaplet a) SnapletConfig

-- | A lens referencing the user-defined state type wrapped by a Snaplet.
snapletValue :: Lens (Snaplet a) a

-- | Transforms a lens of the type you get from makeLenses to an similar
--   lens that is more suitable for internal use.
subSnaplet :: (Lens a (Snaplet b)) -> (Lens (Snaplet a) (Snaplet b))

-- | The m type parameter used in the MonadSnaplet type signatures will
--   usually be either Initializer or Handler, but other monads may
--   sometimes be useful.
--   
--   Minimal complete definition:
--   
--   <ul>
--   <li><a>withTop'</a>, <a>with'</a>, <a>getLens</a>, and
--   <a>getOpaqueConfig</a>.</li>
--   </ul>
class MonadSnaplet m
with :: MonadSnaplet m => (Lens v (Snaplet v')) -> m b v' a -> m b v a
withTop :: MonadSnaplet m => (Lens b (Snaplet v')) -> m b v' a -> m b v a
with' :: MonadSnaplet m => (Lens (Snaplet v) (Snaplet v')) -> m b v' a -> m b v a
withTop' :: MonadSnaplet m => (Lens (Snaplet b) (Snaplet v')) -> m b v' a -> m b v a
getLens :: MonadSnaplet m => m b v (Lens (Snaplet b) (Snaplet v))
getOpaqueConfig :: MonadSnaplet m => m b v SnapletConfig

-- | Gets a list of the names of snaplets that are direct ancestors of the
--   current snaplet.
getSnapletAncestry :: (Monad (m b v), MonadSnaplet m) => m b v [Text]

-- | Gets the snaplet's path on the filesystem.
getSnapletFilePath :: (Monad (m b v), MonadSnaplet m) => m b v FilePath

-- | Gets the current snaple's name.
getSnapletName :: (Monad (m b v), MonadSnaplet m) => m b v (Maybe Text)

-- | Gets a human readable description of the snaplet.
getSnapletDescription :: (Monad (m b v), MonadSnaplet m) => m b v Text

-- | Gets the config data structure for the current snaplet.
getSnapletUserConfig :: (Monad (m b v), MonadSnaplet m) => m b v Config

-- | Gets the base URL for the current snaplet. Directories get added to
--   the current snaplet path by calls to <tt>nestSnaplet</tt>.
getSnapletRootURL :: (Monad (m b v), MonadSnaplet m) => m b v ByteString

-- | Gets the route pattern that matched for the handler. This lets you
--   find out exactly which of the strings you used in addRoutes matched.
getRoutePattern :: Handler b v (Maybe ByteString)

-- | Sets the route pattern that matched for the handler. Use this when to
--   override the default pattern which is the key to the alist passed to
--   addRoutes.
setRoutePattern :: ByteString -> Handler b v ()

-- | Gets the <tt>Snaplet v</tt> from the current snaplet's state.
getSnapletState :: Handler b v (Snaplet v)

-- | Puts a new <tt>Snaplet v</tt> in the current snaplet's state.
putSnapletState :: Snaplet v -> Handler b v ()

-- | Modifies the <tt>Snaplet v</tt> in the current snaplet's state.
modifySnapletState :: (Snaplet v -> Snaplet v) -> Handler b v ()

-- | Gets the <tt>Snaplet v</tt> from the current snaplet's state and
--   applies a function to it.
getsSnapletState :: (Snaplet v -> b) -> Handler b1 v b

-- | Monad used for initializing snaplets.
data Initializer b v a

-- | Opaque newtype which gives us compile-time guarantees that the user is
--   using makeSnaplet and either nestSnaplet or embedSnaplet correctly.
data SnapletInit b v

-- | All snaplet initializers must be wrapped in a call to
--   <tt>makeSnaplet</tt>, which handles standardized housekeeping common
--   to all snaplets. Common usage will look something like this:
--   
--   <pre>
--   fooInit :: SnapletInit b Foo
--   fooInit = makeSnaplet "foo" "An example snaplet" Nothing $ do
--       -- Your initializer code here
--       return $ Foo 42
--   </pre>
--   
--   Note that you're writing your initializer code in the Initializer
--   monad, and makeSnaplet converts it into an opaque SnapletInit type.
--   This allows us to use the type system to ensure that the API is used
--   correctly.
makeSnaplet :: Text -> Text -> Maybe (IO FilePath) -> Initializer b v v -> SnapletInit b v

-- | Runs another snaplet's initializer and returns the initialized Snaplet
--   value. Calling an initializer with nestSnaplet gives the nested
--   snaplet access to the same base state that the current snaplet has.
--   This makes it possible for the child snaplet to make use of
--   functionality provided by sibling snaplets.
nestSnaplet :: ByteString -> (Lens v (Snaplet v1)) -> SnapletInit b v1 -> Initializer b v (Snaplet v1)

-- | Runs another snaplet's initializer and returns the initialized Snaplet
--   value. The difference between this and nestSnaplet is the first type
--   parameter in the third argument. The "v1 v1" makes the child snaplet
--   think that it is top-level, which means that it will not be able to
--   use functionality provided by snaplets included above it in the
--   snaplet tree. This strongly isolates the child snaplet, and allows you
--   to eliminate the b type variable. The embedded snaplet can still get
--   functionality from other snaplets, but only if it nests or embeds the
--   snaplet itself.
embedSnaplet :: ByteString -> (Lens v (Snaplet v1)) -> SnapletInit v1 v1 -> Initializer b v (Snaplet v1)

-- | Sets a snaplet's name. All snaplets have a default name set by the
--   snaplet author. This function allows you to override that name. You
--   will have to do this if you have more than one instance of the same
--   kind of snaplet because snaplet names must be unique. This function
--   must immediately surround the snaplet's initializer. For example:
--   
--   <pre>
--   fooState &lt;- nestSnaplet "fooA" $ nameSnaplet "myFoo" $ fooInit
--   </pre>
nameSnaplet :: Text -> SnapletInit b v -> SnapletInit b v

-- | Attaches an unload handler to the snaplet. The unload handler will be
--   called when the server shuts down, or is reloaded.
onUnload :: IO () -> Initializer b v ()

-- | Adds an IO action that modifies the current snaplet state to be run at
--   the end of initialization on the state that was created. This makes it
--   easier to allow one snaplet's state to be modified by another
--   snaplet's initializer. A good example of this is when a snaplet has
--   templates that define its views. The Heist snaplet provides the
--   <tt>addTemplates</tt> function which allows other snaplets to set up
--   their own templates. <tt>addTemplates</tt> is implemented using this
--   function.
addPostInitHook :: (v -> IO v) -> Initializer b v ()

-- | Variant of addPostInitHook for when you have things wrapped in a
--   Snaplet.
addPostInitHookBase :: (Snaplet b -> IO (Snaplet b)) -> Initializer b v ()

-- | Initializers should use this function for all informational or error
--   messages to be displayed to the user. On application startup they will
--   be sent to the console. When executed from the reloader, they will be
--   sent back to the user in the HTTP response.
printInfo :: Text -> Initializer b v ()

-- | Adds routing to the current <a>Handler</a>. The new routes are merged
--   with the main routing section and take precedence over existing
--   routing that was previously defined.
addRoutes :: [(ByteString, Handler b v ())] -> Initializer b v ()

-- | Wraps the snaplet's routing. This can be used to provide a snaplet
--   that does per-request setup and cleanup, but then dispatches to the
--   rest of the application.
wrapHandlers :: (Handler b v () -> Handler b v ()) -> Initializer b v ()

-- | Snaplet infrastructure is available during runtime request processing
--   through the Handler monad. There aren't very many standalone functions
--   to read about here, but this is deceptive. The key is in the type
--   class instances. Handler is an instance of <a>MonadSnap</a>, which
--   means it is the monad you will use to write all your application
--   routes. It also has a <a>MonadSnaplet</a> instance, which gives you
--   all the functionality described above.
data Handler b v a

-- | Handler that reloads the site.
reloadSite :: Handler b v ()

-- | Given a Snaplet initializer, produce the set of messages generated
--   during initialization, a snap handler, and a cleanup action.
runSnaplet :: SnapletInit b b -> IO (Text, Snap (), IO ())

-- | Given a configuration and a snap handler, complete it and produce the
--   completed configuration as well as a new toplevel handler with things
--   like compression and a 500 handler set up.
combineConfig :: Config Snap a -> Snap () -> IO (Config Snap a, Snap ())

-- | Serves a top-level snaplet as a web application. Reads command-line
--   arguments. FIXME: document this.
serveSnaplet :: Config Snap a -> SnapletInit b b -> IO ()


-- | The Heist snaplet makes it easy to add Heist to your application and
--   use it in other snaplets.
module Snap.Snaplet.Heist

-- | The state for the Heist snaplet. To use the Heist snaplet in your app
--   include this in your application state and use <a>heistInit</a> to
--   initialize it. The type parameter b will typically be the base state
--   type for your application.
data Heist b

-- | A single snaplet should never need more than one instance of Heist as
--   a subsnaplet. This type class allows you to make it easy for other
--   snaplets to get the lens that identifies the heist snaplet. Here's an
--   example of how the heist snaplet might be declared:
--   
--   <pre>
--   data App = App { _heist :: Snaplet (Heist App) }
--   mkLabels [''App]
--   
--   instance HasHeist App where heistLens = subSnaplet heist
--   
--   appInit = makeSnaplet "app" "" Nothing $ do
--       h &lt;- nestSnaplet "heist" heist $ heistInit "templates"
--       addSplices myAppSplices
--       return $ App h
--   </pre>
class HasHeist b
heistLens :: HasHeist b => Lens (Snaplet b) (Snaplet (Heist b))

-- | The <a>Initializer</a> for <a>Heist</a>. This function is a
--   convenience wrapper around <a>heistInit'</a> that uses the default
--   <a>emptyTemplateState</a> from Heist and sets up routes for all the
--   templates.
heistInit :: FilePath -> SnapletInit b (Heist b)

-- | A lower level <a>Initializer</a> for <a>Heist</a>. This initializer
--   requires you to specify the initial TemplateState. It also does not
--   add any routes for templates, allowing you complete control over which
--   templates get routed.
heistInit' :: FilePath -> TemplateState (Handler b b) -> SnapletInit b (Heist b)

-- | Adds templates to the Heist TemplateState. Other snaplets should use
--   this function to add their own templates. The templates are
--   automatically read from the templates directory in the current
--   snaplet's filesystem root.
addTemplates :: HasHeist b => ByteString -> Initializer b v ()

-- | Adds templates to the Heist TemplateState, and lets you specify where
--   they are found in the filesystem.
addTemplatesAt :: HasHeist b => ByteString -> FilePath -> Initializer b v ()

-- | More general function allowing arbitrary TemplateState modification.
--   Without this function you wouldn't be able to bind more complicated
--   splices like the cache tag.
modifyHeistTS :: HasHeist b => (TemplateState (Handler b b) -> TemplateState (Handler b b)) -> Initializer b v ()

-- | Runs a function on with the Heist snaplet's <a>TemplateState</a>.
withHeistTS :: HasHeist b => (TemplateState (Handler b b) -> a) -> Handler b v a

-- | Allows snaplets to add splices.
addSplices :: HasHeist b => [(Text, SnapletSplice b v)] -> Initializer b v ()

-- | Renders a template as text/html. If the given template is not found,
--   this returns <tt>empty</tt>.
render :: HasHeist b => ByteString -> Handler b v ()

-- | Renders a template as the given content type. If the given template is
--   not found, this returns <tt>empty</tt>.
renderAs :: HasHeist b => ByteString -> ByteString -> Handler b v ()

-- | Analogous to <tt>fileServe</tt>. If the template specified in the
--   request path is not found, it returns <tt>empty</tt>.
heistServe :: HasHeist b => Handler b v ()

-- | Analogous to <tt>fileServeSingle</tt>. If the given template is not
--   found, this throws an error.
heistServeSingle :: HasHeist b => ByteString -> Handler b v ()

-- | Runs a handler with a modified <a>TemplateState</a>. You might want to
--   use this if you had a set of splices which were customised for a
--   specific action. To do that you would do:
--   
--   <pre>
--   heistLocal (bindSplices mySplices) handlerThatNeedsSplices
--   </pre>
heistLocal :: HasHeist b => (TemplateState (Handler b b) -> TemplateState (Handler b b)) -> Handler b v a -> Handler b v a

-- | Runs an action with additional splices bound into the Heist
--   <a>TemplateState</a>.
withSplices :: HasHeist b => [(Text, SnapletSplice b v)] -> Handler b v a -> Handler b v a

-- | Renders a template with a given set of splices. This is syntax sugar
--   for a common combination of heistLocal, bindSplices, and render.
renderWithSplices :: HasHeist b => ByteString -> [(Text, SnapletSplice b v)] -> Handler b v ()

-- | Monad for working with Heist's API from within a snaplet.
data SnapletHeist b v a

-- | Type alias for convenience.
type SnapletSplice b v = SnapletHeist b v Template

-- | Lifts a HeistT action into SnapletHeist. Use this with all the
--   functions from the Heist API.
liftHeist :: HeistT (Handler b b) a -> SnapletHeist b v a

-- | Lifts a Handler into SnapletHeist.
liftHandler :: Handler b v a -> SnapletHeist b v a

-- | Lifts a (Handler b b) into SnapletHeist.
liftAppHandler :: Handler b b a -> SnapletHeist b v a

-- | Common idiom for the combination of liftHandler and withTop.
liftWith :: (Lens (Snaplet b) (Snaplet v')) -> Handler b v' a -> SnapletHeist b v a

-- | SnapletSplices version of bindSplices.
bindSnapletSplices :: (Lens (Snaplet b) (Snaplet v)) -> [(Text, SnapletSplice b v)] -> TemplateState (Handler b b) -> TemplateState (Handler b b)

-- | Clears data stored by the cache tag. The cache tag automatically
--   reloads its data when the specified TTL expires, but sometimes you may
--   want to trigger a manual reload. This function lets you do that.
clearHeistCache :: Heist b -> IO ()

module Snap.Snaplet.Session

-- | Any Haskell record that is a member of the <a>ISessionManager</a>
--   typeclass can be stuffed inside a <a>SessionManager</a> to enable all
--   session-related functionality.
data SessionManager

-- | Wrap around a handler, committing any changes in the session at the
--   end
withSession :: (Lens b (Snaplet SessionManager)) -> Handler b v a -> Handler b v a

-- | Commit changes to session within the current request cycle
commitSession :: Handler b SessionManager ()

-- | Set a key-value pair in the current session
setInSession :: Text -> Text -> Handler b SessionManager ()

-- | Get a key from the current session
getFromSession :: Text -> Handler b SessionManager (Maybe Text)

-- | Remove a key from the current session
deleteFromSession :: Text -> Handler b SessionManager ()

-- | Returns a CSRF Token unique to the current session
csrfToken :: Handler b SessionManager Text

-- | Return session contents as an association list
sessionToList :: Handler b SessionManager [(Text, Text)]

-- | Deletes the session cookie, effectively resetting the session
resetSession :: Handler b SessionManager ()

-- | Touch the session so the timeout gets refreshed
touchSession :: Handler b SessionManager ()


-- | This module contains all the central authentication functionality.
--   
--   It exports a number of high-level functions to be used directly in
--   your application handlers.
--   
--   We also export a number of mid-level functions that should be helpful
--   when you are integrating with another way of confirming the
--   authentication of login requests.
module Snap.Snaplet.Auth

-- | Create a new user from just a username and password
--   
--   May throw a <a>DuplicateLogin</a> if given username is not unique
createUser :: Text -> ByteString -> Handler b (AuthManager b) AuthUser

-- | Check whether a user with the given username exists.
usernameExists :: Text -> Handler b (AuthManager b) Bool

-- | Create or update a given user
--   
--   May throw a <a>BackendError</a> if something goes wrong.
saveUser :: AuthUser -> Handler b (AuthManager b) AuthUser

-- | Destroy the given user
--   
--   May throw a <a>BackendError</a> if something goes wrong.
destroyUser :: AuthUser -> Handler b (AuthManager b) ()

-- | Lookup a user by her username, check given password and perform login
loginByUsername :: ByteString -> Password -> Bool -> Handler b (AuthManager b) (Either AuthFailure AuthUser)

-- | Remember user from the remember token if possible and perform login
loginByRememberToken :: Handler b (AuthManager b) (Maybe AuthUser)

-- | Login and persist the given <a>AuthUser</a> in the active session
--   
--   Meant to be used if you have other means of being sure that the person
--   is who she says she is.
forceLogin :: AuthUser -> Handler b (AuthManager b) (Either AuthFailure AuthUser)

-- | Logout the active user
logout :: Handler b (AuthManager b) ()

-- | Return the current user; trying to remember from cookie if possible.
currentUser :: Handler b (AuthManager b) (Maybe AuthUser)

-- | Convenience wrapper around <tt>rememberUser</tt> that returns a bool
--   result
isLoggedIn :: Handler b (AuthManager b) Bool

-- | Mutate an <a>AuthUser</a>, marking successful authentication
--   
--   This will save the user to the backend.
markAuthSuccess :: AuthUser -> Handler b (AuthManager b) AuthUser

-- | Mutate an <a>AuthUser</a>, marking failed authentication
--   
--   This will save the user to the backend.
markAuthFail :: AuthUser -> Handler b (AuthManager b) AuthUser

-- | Authenticate and log the user into the current session if successful.
--   
--   This is a mid-level function exposed to allow roll-your-own ways of
--   looking up a user from the database.
--   
--   This function will:
--   
--   <ol>
--   <li>Check the password</li>
--   <li>Login the user into the current session</li>
--   <li>Mark success/failure of the authentication trial on the user
--   record</li>
--   </ol>
checkPasswordAndLogin :: AuthUser -> Password -> Handler b (AuthManager b) (Either AuthFailure AuthUser)

-- | Abstract data type holding all necessary information for auth
--   operation
data AuthManager b
AuthManager :: r -> Lens b (Snaplet SessionManager) -> Maybe AuthUser -> Int -> ByteString -> Maybe Int -> Key -> Maybe (Int, NominalDiffTime) -> AuthManager b

-- | Storage back-end
backend :: AuthManager b -> r

-- | A lens pointer to a SessionManager
session :: AuthManager b -> Lens b (Snaplet SessionManager)

-- | A per-request logged-in user cache
activeUser :: AuthManager b -> Maybe AuthUser

-- | Password length range
minPasswdLen :: AuthManager b -> Int

-- | Cookie name for the remember token
rememberCookieName :: AuthManager b -> ByteString

-- | Remember period in seconds. Defaults to 2 weeks.
rememberPeriod :: AuthManager b -> Maybe Int

-- | A unique encryption key used to encrypt remember cookie
siteKey :: AuthManager b -> Key

-- | Lockout after x tries, re-allow entry after y seconds
lockout :: AuthManager b -> Maybe (Int, NominalDiffTime)

-- | All storage backends need to implement this typeclass
--   
--   Backend operations may throw <a>BackendError</a>s
class IAuthBackend r
save :: IAuthBackend r => r -> AuthUser -> IO AuthUser
lookupByUserId :: IAuthBackend r => r -> UserId -> IO (Maybe AuthUser)
lookupByLogin :: IAuthBackend r => r -> Text -> IO (Maybe AuthUser)
lookupByRememberToken :: IAuthBackend r => r -> Text -> IO (Maybe AuthUser)
destroy :: IAuthBackend r => r -> AuthUser -> IO ()

-- | Authetication settings defined at initialization time
data AuthSettings
AuthSettings :: Int -> ByteString -> Maybe Int -> Maybe (Int, NominalDiffTime) -> FilePath -> AuthSettings

-- | Currently not used/checked
asMinPasswdLen :: AuthSettings -> Int

-- | Name of the desired remember cookie
asRememberCookieName :: AuthSettings -> ByteString

-- | How long to remember when the option is used in rest of the API.
--   <a>Nothing</a> means remember until end of session.
asRememberPeriod :: AuthSettings -> Maybe Int

-- | Lockout strategy: ([MaxAttempts], [LockoutDuration])
asLockout :: AuthSettings -> Maybe (Int, NominalDiffTime)

-- | Location of app's encryption key
asSiteKey :: AuthSettings -> FilePath

-- | Default settings for Auth.
--   
--   <pre>
--   asMinPasswdLen = 8
--   asRememberCookieName = "_remember"
--   asRememberPeriod = Just (2*7*24*60*60) = 2 weeks
--   asLockout = Nothing
--   asSiteKey = "site_key.txt"
--   </pre>
defAuthSettings :: AuthSettings

-- | Type representing the concept of a User in your application.
data AuthUser
AuthUser :: Maybe UserId -> Text -> Maybe Password -> Maybe UTCTime -> Maybe UTCTime -> Maybe Text -> Int -> Int -> Maybe UTCTime -> Maybe UTCTime -> Maybe UTCTime -> Maybe ByteString -> Maybe ByteString -> Maybe UTCTime -> Maybe UTCTime -> [Role] -> HashMap Text Value -> AuthUser
userId :: AuthUser -> Maybe UserId
userLogin :: AuthUser -> Text
userPassword :: AuthUser -> Maybe Password
userActivatedAt :: AuthUser -> Maybe UTCTime
userSuspendedAt :: AuthUser -> Maybe UTCTime
userRememberToken :: AuthUser -> Maybe Text
userLoginCount :: AuthUser -> Int
userFailedLoginCount :: AuthUser -> Int
userLockedOutUntil :: AuthUser -> Maybe UTCTime
userCurrentLoginAt :: AuthUser -> Maybe UTCTime
userLastLoginAt :: AuthUser -> Maybe UTCTime
userCurrentLoginIp :: AuthUser -> Maybe ByteString
userLastLoginIp :: AuthUser -> Maybe ByteString
userCreatedAt :: AuthUser -> Maybe UTCTime
userUpdatedAt :: AuthUser -> Maybe UTCTime
userRoles :: AuthUser -> [Role]
userMeta :: AuthUser -> HashMap Text Value

-- | Default AuthUser that has all empty values.
defAuthUser :: AuthUser

-- | Internal representation of a <tt>User</tt>. By convention, we demand
--   that the application is able to directly fetch a <tt>User</tt> using
--   this identifier.
--   
--   Think of this type as a secure, authenticated user. You should
--   normally never see this type unless a user has been authenticated.
newtype UserId
UserId :: Text -> UserId
unUid :: UserId -> Text

-- | Password is clear when supplied by the user and encrypted later when
--   returned from the db.
data Password
ClearText :: ByteString -> Password
Encrypted :: ByteString -> Password

-- | Authentication failures indicate what went wrong during
--   authentication. They may provide useful information to the developer,
--   although it is generally not advisable to show the user the exact
--   details about why login failed.
data AuthFailure
UserNotFound :: AuthFailure
IncorrectPassword :: AuthFailure
PasswordMissing :: AuthFailure

-- | Locked out until given time
LockedOut :: UTCTime -> AuthFailure
AuthError :: String -> AuthFailure
data BackendError
DuplicateLogin :: BackendError
BackendError :: String -> BackendError

-- | This will be replaced by a role-based permission system.
data Role
Role :: ByteString -> Role

-- | Run a function on the backend, and return the result.
--   
--   This uses an existential type so that the backend type doesn't
--   <tt>escape</tt> AuthManager. The reason that the type is Handler b
--   (AuthManager v) a and not a is because anything that uses the backend
--   will return an IO something, which you can liftIO, or a Handler b
--   (AuthManager v) a if it uses other handler things.
withBackend :: (forall r. IAuthBackend r => r -> Handler b (AuthManager v) a) -> Handler b (AuthManager v) a
encryptPassword :: Password -> IO Password
checkPassword :: Password -> Password -> Bool

-- | Check password for a given user.
--   
--   Returns <a>Nothing</a> if check is successful and an
--   <a>IncorrectPassword</a> error otherwise
authenticatePassword :: AuthUser -> Password -> Maybe AuthFailure

-- | Set a new password for the given user. Given password should be
--   clear-text; it will be encrypted into a <a>Encrypted</a>.
setPassword :: AuthUser -> ByteString -> IO AuthUser

-- | Register a new user by specifying login and password <tt>Param</tt>
--   fields
registerUser :: ByteString -> ByteString -> Handler b (AuthManager b) AuthUser

-- | A <a>MonadSnap</a> handler that processes a login form.
--   
--   The request paremeters are passed to <tt>performLogin</tt>
loginUser :: ByteString -> ByteString -> Maybe ByteString -> (AuthFailure -> Handler b (AuthManager b) ()) -> Handler b (AuthManager b) () -> Handler b (AuthManager b) ()

-- | Simple handler to log the user out. Deletes user from session.
logoutUser :: Handler b (AuthManager b) () -> Handler b (AuthManager b) ()

-- | Require that an authenticated <a>AuthUser</a> is present in the
--   current session.
--   
--   This function has no DB cost - only checks to see if a user_id is
--   present in the current session.
requireUser :: Lens b (Snaplet (AuthManager b)) -> Handler b v a -> Handler b v a -> Handler b v a

-- | Add all standard auth splices to a Heist-enabled application.
--   
--   This adds the following splices: &lt;ifLoggedIn&gt;
--   &lt;ifLoggedOut&gt;
addAuthSplices :: HasHeist b => Lens b (Snaplet (AuthManager b)) -> Initializer b v ()

-- | A splice that can be used to check for existence of a user. If a user
--   is present, this will run the contents of the node.
--   
--   <pre>
--   &lt;ifLoggedIn&gt; Show this when there is a logged in user &lt;/ifLoggedIn&gt;
--   </pre>
ifLoggedIn :: Lens b (Snaplet (AuthManager b)) -> SnapletSplice b v

-- | A splice that can be used to check for absence of a user. If a user is
--   not present, this will run the contents of the node.
--   
--   <pre>
--   &lt;ifLoggedOut&gt; Show this when there is a logged in user &lt;/ifLoggedOut&gt;
--   </pre>
ifLoggedOut :: Lens b (Snaplet (AuthManager b)) -> SnapletSplice b v

module Snap.Snaplet.Auth.Backends.JsonFile

-- | Initialize a JSON file backed <a>AuthManager</a>
initJsonFileAuthManager :: AuthSettings -> Lens b (Snaplet SessionManager) -> FilePath -> SnapletInit b (AuthManager b)

-- | Load/create a datafile into memory cache and return the manager.
--   
--   This data type can be used by itself for batch/non-handler processing.
mkJsonAuthMgr :: FilePath -> IO JsonFileAuthManager
instance FromJSON Password
instance ToJSON Password
instance FromJSON AuthUser
instance ToJSON AuthUser
instance FromJSON UserCache
instance ToJSON UserCache
instance IAuthBackend JsonFileAuthManager
instance FromJSON UserIdCache
instance ToJSON UserIdCache

module Snap.Snaplet.Session.Backends.CookieSession

-- | Initialize a cookie-backed session, returning a <a>SessionManager</a>
--   to be stuffed inside your application's state. This
--   <a>SessionManager</a> will enable the use of all session storage
--   functionality defined in <tt>Snap.Snaplet.Session</tt>
initCookieSessionManager :: FilePath -> ByteString -> Maybe Int -> SnapletInit b SessionManager
instance Typeable CookieSessionManager
instance Eq CookieSession
instance Show CookieSession
instance Show CookieSessionManager
instance Eq Payload
instance Show Payload
instance Ord Payload
instance Serialize Payload
instance ISessionManager CookieSessionManager
instance (Serialize k, Serialize v, Hashable k, Eq k) => Serialize (HashMap k v)
instance Serialize CookieSession


-- | This module provides convenience exports of the modules most commonly
--   used when developing with the Snap Framework. For documentation about
--   Snaplets, see <a>Snap.Snaplet</a>. For the core web server API, see
--   <a>Snap.Core</a>.
module Snap