[{"name":"Express","comment":" `elm-express` is an Elm library that provides a lightweight and expressive API for building server-side applications\non top of the popular Node.js web framework, Express. With `elm-express`, developers can leverage the safety and\nexpressiveness of Elm for building web backends in a familiar and powerful environment.\n\n\n# How it works?\n\nWhen an incoming request arrives, Express.js sends the request data through a port called `requestPort` to the Elm\napplication, which can then define a response and route it through another port called `responsePort`.\n\nTo simplify the integration between the Express.js server and the Elm application, `elm-express` comes with a JavaScript\nlibrary that takes care of most of the wiring. The README contains documentation on how to use the library, and the\n`/example` folder in the repository provides a practical demonstration of how to wire everything up.\n\n\n# Creating an `elm-express` application\n\n@docs application\n\n\n# Types\n\n@docs AppInit, AppIncoming, AppUpdate, AppDecodeRequestId, ApplicationParams\n\n\n# Internal types\n\n@docs Pool, Model, Msg\n\n","unions":[{"name":"Msg","comment":" Internal messages.\n","args":["msg"],"cases":[]}],"aliases":[{"name":"AppDecodeRequestId","comment":" The `AppDecodeRequestId` type alias represents the `decodeRequestId` function, which is called whenever a\nsubscription message is received. This function extracts the request ID from the message value in order to select the\nconnection associated with the request.\n","args":["msg"],"type":"msg -> Result.Result Json.Decode.Error String.String"},{"name":"AppIncoming","comment":" Describes the `incoming` function that gets called whenever a new request happens.\n","args":["ctx","msg","model"],"type":"ctx -> Express.Request.Request -> Express.Response.Response -> ( Express.Conn.Conn model, Platform.Cmd.Cmd msg )"},{"name":"AppInit","comment":" The `AppInit` type alias represents the `init` function that runs when the application is started. It is similar to\nthe `init` function of [`Platform.worker`](https://package.elm-lang.org/packages/elm/core/latest/Platform#worker), and\nprovides an opportunity to pass in \"context\" data that can be used throughout the application.\n\nThis is an ideal place to provide any data that will not change during the application's lifecycle, such as environment\nvariables. By passing such data as context, you can ensure that it is available to all parts of the application that\nneed it.\n\n","args":["flags","ctx"],"type":"flags -> ctx"},{"name":"AppUpdate","comment":" The `AppUpdate` type alias represents the `update` function of your Elm application. This function is responsible\nfor processing messages that are typically tied to port or task interactions.\n\nThe update function takes three arguments: a context (`ctx`), a message (`msg`), and a connection (`Conn.Conn model`)\nthat represents the current state of the application. Based on these inputs, the function returns a tuple containing a\nnew connection (`Conn.Conn model`) and any commands (`Cmd msg`) that should be executed as a result of the message\nprocessing.\n\n","args":["msg","model","ctx"],"type":"ctx -> msg -> Express.Conn.Conn model -> ( Express.Conn.Conn model, Platform.Cmd.Cmd msg )"},{"name":"ApplicationParams","comment":" The `ApplicationParams` type alias represents all the parameters that need to be set up for your Elm application to\nwork with `elm-express`. In addition to well-known functions like `init` and `update`, you need to provide four\ndifferent ports that will be used for wiring:\n\n  - `requestPort`\n  - `responsePort`\n  - `poolPort`\n  - `errorPort`\n\nYou can also provide a list of middlewares to run at every request. Please refer to the `Express.Middleware`\ndocumentation to learn how to use middleware.\n\nFor a full example of how to instantiate a new `ApplicationParams` value, see the `/example` folder in the\nrepository/source.\n\n","args":["flags","ctx","msg","model"],"type":"{ requestPort : (Json.Decode.Value -> Express.Msg msg) -> Platform.Sub.Sub (Express.Msg msg), responsePort : Json.Encode.Value -> Platform.Cmd.Cmd (Express.Msg msg), errorPort : String.String -> Platform.Cmd.Cmd (Express.Msg msg), poolPort : (String.String -> Express.Msg msg) -> Platform.Sub.Sub (Express.Msg msg), init : Express.AppInit flags ctx, incoming : Express.AppIncoming ctx msg model, decodeRequestId : Express.AppDecodeRequestId msg, update : Express.AppUpdate msg model ctx, subscriptions : Platform.Sub.Sub msg, middlewares : List.List (Express.Middleware.Middleware ctx msg) }"},{"name":"Model","comment":" Internal model.\n","args":["model","ctx"],"type":"{ pool : Express.Pool model, context : ctx }"},{"name":"Pool","comment":" Internal connections pool.\n","args":["model"],"type":"Dict.Dict String.String (Express.Conn.Conn model)"}],"values":[{"name":"application","comment":" This function wraps the [`Platform.worker`](https://package.elm-lang.org/packages/elm/core/latest/Platform#worker)\nfunction to create a \"headless\" Elm application that should be instantiated by a Node.js script.\n\nFor a more in-depth understanding of how to use this library and create your own application, take a look at the app in\nthe `/example` folder in the repository/source.\n\n","type":"Express.ApplicationParams flags ctx msg model -> Platform.Program flags (Express.Model model ctx) (Express.Msg msg)"}],"binops":[]},{"name":"Express.Conn","comment":" This module provides access to the Conn type, which combines three types: `Express.Request`, `Express.Response`, and\nyour application's model/state. The `Conn` type is designed to easily transfer request information through your\napplication's functions.\n\n\n# Types\n\n@docs Conn\n\n\n# Helpers\n\n@docs send\n\n","unions":[],"aliases":[{"name":"Conn","comment":" The `Conn` type is a combination of the `Express.Request`, `Express.Response` types and your application's\nmodel/state. It is used to efficiently pass request information through your app's functions.\n","args":["model"],"type":"{ request : Express.Request.Request, response : Express.Response.Response, model : model }"}],"values":[{"name":"send","comment":" The `send` function is a utility function that encodes a `Conn` into a JSON object that can be sent through the\n`responsePort` of your application. The JavaScript part of `elm-express` expects the JSON object to have a certain\nformat, which can be achieved using this function. Once the `Conn` has been encoded, you can use the following pattern\nto send your responses:\n\n    conn |> Express.Conn.send |> responsePort\n\nThis will send the encoded `Conn` through the `responsePort`, allowing you to respond to the client with the\nappropriate data.\n\n","type":"Express.Conn.Conn model -> Json.Encode.Value"}],"binops":[]},{"name":"Express.Cookie","comment":" This module provides a set of types and functions that allow you to manage cookies in your `elm-express`\napplication. This includes setting, reading, and deleting cookies during requests. The module offers a range of options\nfor working with cookies, such as setting the expiration date and domain for a cookie. By using the functions provided\nin this module, you can ensure that cookies are managed securely and efficiently within your application.\n\nIt aims to provide a straightforward way to work with cookies in Elm that is based on the Express.js API, while also\nincluding some slight adaptations when necessary. To a more comprehensive understanding it is recommended to read the\nExpress.js [documentation](https://expressjs.com/en/4x/api.html#res.cookie) surrounding cookie setting.\n\n\n# Types\n\n@docs Cookie, SameSite\n\n\n# Creating a cookie\n\n@docs new\n\n\n# Handling cookies\n\n@docs domain, maxAge, httpOnly, path, secure, signed, sameSite\n\n","unions":[{"name":"SameSite","comment":" The `SameSite` type describe the three possible values for the `sameSite` key in the cookie definition. To better\nunderstand the effects of each value we recommend [this article](https://owasp.org/www-community/SameSite) from the\nOWASP website.\n","args":[],"cases":[["None",[]],["Strict",[]],["Lax",[]]]}],"aliases":[{"name":"Cookie","comment":" The `Cookie` type is an [opaque type](https://sporto.github.io/elm-patterns/advanced/opaque-types.html) that\ndescribes a cookie according with Express.js APIs. It contains all the required information on the Express.js\n[documentation](https://expressjs.com/en/4x/api.html#res.cookie) to define a cookie.\n\nOne particular difference is that we don't use the `expires` key, only the `maxAge` key. That means you can't specify a\nprecise date and time in which the cookie will expire, only how long it will live from the current server time when the\ncookie is set.\n\nThis difference exists to simplify the interface as dealing with dates would be more troublesome (while still completely\npossible).\n\n","args":[],"type":"Express.Internal.Cookie.Cookie"}],"values":[{"name":"domain","comment":" Sets the `domain` property of the cookie. Defaults to the host of the request's URL.\n\n    newCookie =\n        Express.Cookie.domain \"subdomain.example.com\" oldCookie\n\n","type":"String.String -> Express.Cookie.Cookie -> Express.Cookie.Cookie"},{"name":"httpOnly","comment":" Sets the `httpOnly` property of the cookie. If `httpOnly` is `True` the cookie is only accessible through the web\nserver, making it impossible to fetch the cookie via JavaScript in the client side. `True` is the default value when you\ncreate a new `Cookie`.\n\n    newCookie =\n        -- The contents of this cookie will be accessible in client side JavaScript code\n        Express.Cookie.httpOnly False oldCookie\n\n","type":"Basics.Bool -> Express.Cookie.Cookie -> Express.Cookie.Cookie"},{"name":"maxAge","comment":" Sets or unsets the `maxAge` property of the cookie. Passing a `Nothing` value will turn the cookie into a session\ncookie.\n\n    newCookie =\n        Express.Cookie.maxAge (Just 3600000) oldCookie\n\n","type":"Maybe.Maybe Basics.Int -> Express.Cookie.Cookie -> Express.Cookie.Cookie"},{"name":"new","comment":" Creates a new `Cookie`. It tries to use the most sensible defaults optimized for security. That means that:\n\n  - `domain` is defined using the request's URL host\n  - `path` is the root `/`\n  - `httpOnly` is `True`\n  - `secure` is defined according to the request's URL protocol\n  - `signed` is `True` and\n  - `sameSite` is `Strict`\n\nAll of these parameters you can later change with functions from this module.\n\nThe `maxAge` needs to be informed in milliseconds. If omitted by passing in a `Nothing` value, the cookie will be set as\na session cookie.\n\n    cookie =\n        -- expires in 30 minutes\n        Express.Cookie.new \"cookieName\" \"cookieValue\" (Just 1800000)\n\nIf you need to store more complex data, make sure to encode it to a string before creating the cookie itself.\n\n","type":"Express.Request.Request -> String.String -> String.String -> Maybe.Maybe Basics.Int -> Express.Cookie.Cookie"},{"name":"path","comment":" Sets the `path` property of the cookie. Defaults to the root `/`. Changing this value will make the cookie only\navailable in the specified path and its subdirectories.\n\n    newCookie =\n        Express.Cookie.path \"/api\" oldCookie\n\n","type":"String.String -> Express.Cookie.Cookie -> Express.Cookie.Cookie"},{"name":"sameSite","comment":" Sets the `sameSite` property of the cookie. To better understand what each value means check\n[this reference](https://owasp.org/www-community/SameSite) from the OWASP website. Defaults to `Strict`.\n\n    newCookie =\n        Express.Cookie.sameSite Express.Cookie.Lax oldCookie\n\n","type":"Express.Cookie.SameSite -> Express.Cookie.Cookie -> Express.Cookie.Cookie"},{"name":"secure","comment":" Sets the `secure` property of the cookie. If `secure` is `True` than the cookie will only be readable from secure\n(https) connections. The default value depends on the protocol from the request's URL. If it is `Https`, than `secure`\nwill be `True`.\n\n    newCookie =\n        Express.Cookie.secure True oldCookie\n\n","type":"Basics.Bool -> Express.Cookie.Cookie -> Express.Cookie.Cookie"},{"name":"signed","comment":" Sets the `signed` property of the cookie. Signed cookies can only be read when the secrets match. You can set a\nsecret when creating an `elmExpress` application in the JavaScript land code. This prevents tampering of data, making\nthe cookie unavailable if it was not signed with the correct secret.\n\nIt is important to note that this does not encrypt the cookies value, as it will be exposed somehow. Defaults to `True`.\n\n    newCookie =\n        Express.Cookie.signed True oldCookie\n\n","type":"Basics.Bool -> Express.Cookie.Cookie -> Express.Cookie.Cookie"}],"binops":[]},{"name":"Express.Middleware","comment":" This module exposes a very simple middleware system.\n\n\n# Types\n\n@docs Middleware\n\n\n# Running middlewares\n\n@docs run\n\n","unions":[],"aliases":[{"name":"Middleware","comment":" Middlewares are simple functions that will receive your application's context, a request and a response as\nparameters, and return a response and command. Remember that you can lock a response inside your middlewares. To better\nunderstand what is a locked response, please refer to the `Express.Response` module documentation.\n\n    authMiddleware context request response =\n        case Express.Request.cookie \"user\" request of\n            Just _ ->\n                ( response, Cmd.none )\n\n            Nothing ->\n                let\n                    newResponse =\n                        response |> Express.Response.redirect \"/login\"\n                in\n                ( newResponse, newResponse |> Response.send request |> responsePort )\n\n","args":["ctx","msg"],"type":"ctx -> Express.Request.Request -> Express.Response.Response -> ( Express.Response.Response, Platform.Cmd.Cmd msg )"}],"values":[{"name":"run","comment":" Given a list of middleware functions, you can run them all in sequence by using the `run` function. Think of this\nfunction as a reducer or folding function that will aggregate the transformations from all middlewares into a single\n`( response, command )` tuple.\n\n    let\n        middlewares =\n            [ flashMsgMiddleware, authMiddleware ]\n    in\n    ( newResponse, newCmd ) =\n        run context request response middlewares\n\n","type":"ctx -> Express.Request.Request -> Express.Response.Response -> List.List (Express.Middleware.Middleware ctx msg) -> ( Express.Response.Response, Platform.Cmd.Cmd msg )"}],"binops":[]},{"name":"Express.Request","comment":" This module exposes ways of dealing with requests. Requests are only \"acquired\" when a new request incomes to the\napplication. You should be able to access most of the original attributes of a request coming from Express.js with the\nmethods exposed in this method.\n\nEverything should be \"read-only\" so there is no way to change a request, only read from its attributes.\n\n\n# Types\n\n@docs Request, Method\n\n\n# Reading from requests\n\n@docs id, method, url, body, now, headers, header, cookies, cookie, session\n\n\n# Helpers\n\n@docs decodeRequestId\n\n","unions":[{"name":"Method","comment":" Defines the possible HTTP methods from a request.\n","args":[],"cases":[["Get",[]],["Head",[]],["Post",[]],["Put",[]],["Delete",[]],["Patch",[]]]}],"aliases":[{"name":"Request","comment":" The `Request` is an [opaque type](https://sporto.github.io/elm-patterns/advanced/opaque-types.html) that holds the\ndata from the request. It should have most of the readable attributes as described in the\n[Express.js API reference](https://expressjs.com/en/4x/api.html#req).\n","args":[],"type":"Express.Internal.Request.Request"}],"values":[{"name":"body","comment":" Gives access to the body of the request.\n\n`elm-express` will always return the body as a `String` so it is your job to decode whatever is the content into the\ndesired type. If you are getting a JSON payload, you can leverage Elm's own\n[`Json.Decode.decodeString`](https://package.elm-lang.org/packages/elm/json/latest/Json-Decode#decodeString) and if it\nis a form payload, Elm's [`Url.Parser.Query`](https://package.elm-lang.org/packages/elm/url/latest/Url-Parser-Query)\nshould be up for the job.\n\n    simpleBody =\n        Express.Request.body request\n\n","type":"Express.Request.Request -> String.String"},{"name":"cookie","comment":" Gets the value of a specific cookie. All cookies, signed or not, can be accessed through this function.\n\n    lastVisit =\n        Express.Request.cookie \"lastVisit\" request\n\n","type":"String.String -> Express.Request.Request -> Maybe.Maybe String.String"},{"name":"cookies","comment":" Returns all the request's cookies in a `Dict`. Although Express.js makes a distinction between signed and unsigned\ncookies, making them accessible with different attributes, _all_ cookies, signed or not, will be be available in this\n`Dict`.\n\n    cookies =\n        Express.Request.cookies request\n\n","type":"Express.Request.Request -> Dict.Dict String.String String.String"},{"name":"decodeRequestId","comment":" This is a helper function that takes a `Json.Decode.Value` (most likely a JSON object from JavaScript) and extracts\nthe `requestId` key from such `Value`. It is very useful when defining the `decodeRequestId` function when creating your\napplication with `Express.application`. For an example on how this can be used, check the `/example` folder in the\nrepository/source.\n","type":"Json.Decode.Value -> Result.Result Json.Decode.Error String.String"},{"name":"header","comment":" Fetches a specific header from the request.\n\n    isAjax =\n        request\n            |> Express.Request.header \"X-Requested-With\"\n            |> Maybe.map ((==) \"XMLHttpRequest\")\n            |> Maybe.withDefault False\n\n","type":"String.String -> Express.Request.Request -> Maybe.Maybe String.String"},{"name":"headers","comment":" Returns all the request's headers in a `Dict`.\n\n    headers =\n        Express.Request.headers request\n\n","type":"Express.Request.Request -> Dict.Dict String.String String.String"},{"name":"id","comment":" All requests have an attached unique identifier. This function exposes such id of the request being passed. Id's are\njust UUID (v4) strings and they are used to track requests inside and outside the Elm application.\n\n    myId =\n        Express.Request.id request\n\n","type":"Express.Request.Request -> String.String"},{"name":"method","comment":" Returns the request's method. Nice to use when pattern matching for specific routes. For a good example on how this\ncould be used, look at the `/example` folder in the repository/source.\n\n    method =\n        Express.Request.method request\n\n","type":"Express.Request.Request -> Express.Request.Method"},{"name":"now","comment":" This exposes the `Time.Posix` of the moment the request arrived, relative to the server time.\n\n    rightNow =\n        Express.Request.now request\n\n","type":"Express.Request.Request -> Time.Posix"},{"name":"session","comment":" Allows access to specific session keys. Details on how you can setup your session are in the documentation for the\nJavaScript portion of this library. Please refer to the `README` for that.\n\n    user =\n        Express.Request.session \"user\" request\n\n","type":"String.String -> Express.Request.Request -> Maybe.Maybe String.String"},{"name":"url","comment":" The `url` function will return an Elm `Url` describing the current request details. For more information, please\nrefer to Elm's original [docs for URLs](https://package.elm-lang.org/packages/elm/url/latest/Url#Url).\n\nBecause `elm-express` does not have a dedicated router, you can use the URL data to perform routing like you would if\nyou were creating an SPA with Elm. Elm's guide on [Parsing URLs](https://guide.elm-lang.org/webapps/url_parsing.html)\nshould be a very good starting point to understand how we can leverage Elm's APIs with `elm-express` for routing.\n\nFor a more detailed example, look at the `/example` folder in the repository/source.\n\n    url =\n        Express.Request.url request\n\n","type":"Express.Request.Request -> Url.Url"}],"binops":[]},{"name":"Express.Response","comment":" This module allows you to create new responses and manipulate them in order to send them to the client. It tries to\nsimplify the interaction compared with the original [Express.js API](https://expressjs.com/en/4x/api.html#res) by\nallowing only one way to define things and going to the lowest layers while abstracting some inconsistencies and\nproviding type safety to the response definition.\n\n\n# Types\n\n@docs Response, Status, Redirect\n\n\n# Creating responses\n\n@docs new\n\n\n# Adding content\n\n@docs text, json, html, status, setHeader\n\n\n# Redirecting\n\n@docs redirect, rawRedirect\n\n\n# Cookies\n\n@docs setCookie, unsetCookie\n\n\n# Session\n\n@docs setSession, unsetSession\n\n\n# Manipulating responses\n\n@docs lock, map\n\n\n# Helpers\n\n@docs send\n\n","unions":[{"name":"Redirect","comment":" The `Redirect` type defines the possible redirection statuses you can use when sending a response.\n\nReference: <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages>\n\n","args":[],"cases":[["MovedPermanently",["String.String"]],["Found",["String.String"]]]},{"name":"Response","comment":" The `Response` type wraps the actual definition of your response. It can appear in two different states:\n\n  - `Unlocked`: means you can manipulate the response and change its properties;\n  - `Locked`: means that whatever changes you perform in the response won't have any effect.\n\nWhen you create a new response using the `new` function, it will be `Unlocked` by default. You can always lock a\nresponse using the `lock` function.\n\nBut why do we need that? Consider that you have a middleware that will check if the user is logged in, and if they are\nnot, you want to redirect to the login page. The middleware will run at the very start of the request cycle and you\nprobably don't want any other parts of your application to change the state of the response if the user needs to be\nredirected. That is why we lock the response. Once locked, the response's state will never change and whatever your\nmiddleware decided to do will be respected.\n\n","args":[],"cases":[]},{"name":"Status","comment":" The `Status` type describes the possible response statuses that you can send.\n\nReference: <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status>\n\n","args":[],"cases":[["OK",[]],["NotFound",[]],["InternalServerError",[]]]}],"aliases":[],"values":[{"name":"html","comment":" Sets a HTML response. The HTML should be represented as a string but you can use packages like\n[zwilias/elm-html-string](https://package.elm-lang.org/packages/zwilias/elm-html-string/latest/) to generate HTML like\nyou would for front-end code. We also include a `Html.String.Extra` module with `elm-review` to allow you to create\nfull HTML documents.\n\nThere is a full example in the `/example` folder in the repository/source.\n\n    htmlResponse =\n        Express.Response.html \"<h1>Hello World</h1>\" response\n\n","type":"String.String -> Express.Response.Response -> Express.Response.Response"},{"name":"json","comment":" Sets a JSON response.\n\n    jsonResponse =\n        Express.Response.text encodedValue response\n\n","type":"Json.Encode.Value -> Express.Response.Response -> Express.Response.Response"},{"name":"lock","comment":" Locks the response guaranteeing that it can't be changed after this fact.\n\n    lockedResponse =\n        Express.Response.lock unlockedResponse\n\n","type":"Express.Response.Response -> Express.Response.Response"},{"name":"map","comment":" When manipulating responses it is advised to wrap those manipulations inside the `map` function.\n\nImagine that you have something expensive to run during a request, but the existing response you are manipulating has\nbeen locked. Using the `map` function you guarantee that any manipulation will only be called if the response is\nunlocked.\n\n    newResponse =\n        oldResponse |> Express.Response.map (Express.Response.text \"IT WORKS!\")\n\n","type":"(Express.Response.Response -> Express.Response.Response) -> Express.Response.Response -> Express.Response.Response"},{"name":"new","comment":" Creates a new, mostly empty, response. It will have a `OK` status and an empty text body. Once created you can\nmanipulate the contents of the response with other functions from this module.\n\n    response =\n        Express.Response.new\n\n","type":"Express.Response.Response"},{"name":"rawRedirect","comment":" Makes the response directs to another URL/path using the specified `Redirect` type you wanna use.\n\n_Attention_: this function **locks** the response.\n\n    redirect =\n        Express.Response.rawRedirect (Express.Response.MovedPermanently \"/new-blog/article/123\") response\n\n","type":"Express.Response.Redirect -> Express.Response.Response -> Express.Response.Response"},{"name":"redirect","comment":" Makes the response redirect to another URL/path. This will make a simple `Found` (302) redirect. To use other\nredirection statuses, use `rawRedirect`.\n\n_Attention_: this function **locks** the response.\n\n    redirect =\n        Express.Response.redirect \"/login\" response\n\n","type":"String.String -> Express.Response.Response -> Express.Response.Response"},{"name":"send","comment":" Helper function to send a response. This is most useful if you still don't have a `Conn` in place like in\nmiddlewares. When you have a `Conn` you can use `Express.Conn.send` instead.\n\nHere is how you can use this to create a response command:\n\n    cmd =\n        Express.Response send request response |> responsePort\n\n","type":"Express.Request.Request -> Express.Response.Response -> Json.Encode.Value"},{"name":"setCookie","comment":" Sets a cookie with the response. To learn how to create a new cookie visit the docs for `Express.Cookie` module.\n\n    newResponse =\n        Express.Response.setCookie myCookie oldResponse\n\n","type":"Express.Cookie.Cookie -> Express.Response.Response -> Express.Response.Response"},{"name":"setHeader","comment":" Sets a header in the response.\n\n    newResponse =\n        Express.Response.setHeader\n            \"X-Awesome-Header\"\n            \"Look ma! No JS!\"\n            oldResponse\n\n","type":"String.String -> String.String -> Express.Response.Response -> Express.Response.Response"},{"name":"setSession","comment":" Sets a new session data.\n\n    newResponse =\n        Express.Response.setSession \"user\" userDataAsString oldResponse\n\n","type":"String.String -> String.String -> Express.Response.Response -> Express.Response.Response"},{"name":"status","comment":" Sets the status of the response.\n\n    somethingTerribleHasHappened =\n        Express.Response.status Express.Response.InternalServerError response\n\n","type":"Express.Response.Status -> Express.Response.Response -> Express.Response.Response"},{"name":"text","comment":" Sets a plain text response.\n\n    textResponse =\n        Express.Response.text \"Hello world!\" response\n\n","type":"String.String -> Express.Response.Response -> Express.Response.Response"},{"name":"unsetCookie","comment":" Deletes a cookie. In order to delete a cookie you must recreate it with the same properties as the original cookie\nexcluding `maxAge`.\n\n    newResponse =\n        Express.Response.unsetCookie badCookie oldResponse\n\n","type":"Express.Cookie.Cookie -> Express.Response.Response -> Express.Response.Response"},{"name":"unsetSession","comment":" Deletes a session data.\n\n    newResponse =\n        Express.Response.unsetSession \"flashMsg\" oldResponse\n\n","type":"String.String -> Express.Response.Response -> Express.Response.Response"}],"binops":[]},{"name":"Html.String.Extra","comment":" Extends on the [zwilias/elm-html-string](https://package.elm-lang.org/packages/zwilias/elm-html-string/latest/)\npackage adding extra HTML tags and attributes to fully represent an HTML document as the original package, as well as\nthe original [elm/html](https://package.elm-lang.org/packages/elm/html/latest/) package, does not have tags for things\nlike `<html>`, `<head>` and `<body>`.\n\n@docs html, head, title, meta, link, script, style, base, body\n\n","unions":[],"aliases":[],"values":[{"name":"base","comment":" Specifies the base URL to use for all relative URLs in a document. There can be only one such element in a document\n([source](https://developer.mozilla.org/en-US/docs/Web/HTML/Element)).\n","type":"List.List (Html.String.Attribute msg) -> Html.String.Html msg"},{"name":"body","comment":" Represents the content of an HTML document. There can be only one such element in a document.\n([source](https://developer.mozilla.org/en-US/docs/Web/HTML/Element)).\n","type":"List.List (Html.String.Attribute msg) -> List.List (Html.String.Html msg) -> Html.String.Html msg"},{"name":"head","comment":" Contains machine-readable information (metadata) about the document, like its title, scripts, and style sheets\n([source](https://developer.mozilla.org/en-US/docs/Web/HTML/Element)).\n","type":"List.List (Html.String.Attribute msg) -> List.List (Html.String.Html msg) -> Html.String.Html msg"},{"name":"html","comment":" Represents the root (top-level element) of an HTML document, so it is also referred to as the root element. All\nother elements must be descendants of this element\n([source](https://developer.mozilla.org/en-US/docs/Web/HTML/Element)).\n","type":"List.List (Html.String.Attribute msg) -> List.List (Html.String.Html msg) -> Html.String.Html msg"},{"name":"link","comment":" Specifies relationships between the current document and an external resource. This element is most commonly used\nto link to CSS, but is also used to establish site icons (both \"favicon\" style icons and icons for the home screen and\napps on mobile devices) among other things\n([source](https://developer.mozilla.org/en-US/docs/Web/HTML/Element)).\n","type":"List.List (Html.String.Attribute msg) -> Html.String.Html msg"},{"name":"meta","comment":" Represents metadata that cannot be represented by other HTML meta-related elements, like `<base>`, `<link>`,\n`<script>`, `<style>` and `<title>`\n([source](https://developer.mozilla.org/en-US/docs/Web/HTML/Element)).\n","type":"List.List (Html.String.Attribute msg) -> Html.String.Html msg"},{"name":"script","comment":" Used to embed executable code or data; this is typically used to embed or refer to JavaScript code. The `<script>`\nelement can also be used with other languages, such as WebGL's GLSL shader programming language and JSON\n([source](https://developer.mozilla.org/en-US/docs/Web/HTML/Element)).\n\n**Note**: `elm-html-string` automatically escapes all text content, making the usage of this tag for actual scripts\nalmost impossible. It is best to embed scripts from other files.\n\n","type":"List.List (Html.String.Attribute msg) -> String.String -> Html.String.Html msg"},{"name":"style","comment":" Contains style information for a document, or part of a document. It contains CSS, which is applied to the contents\nof the document containing this element\n([source](https://developer.mozilla.org/en-US/docs/Web/HTML/Element)).\n","type":"List.List (Html.String.Attribute msg) -> String.String -> Html.String.Html msg"},{"name":"title","comment":" Defines the document's title that is shown in a browser's title bar or a page's tab. It only contains text; tags\nwithin the element are ignored\n([source](https://developer.mozilla.org/en-US/docs/Web/HTML/Element)).\n","type":"List.List (Html.String.Attribute msg) -> String.String -> Html.String.Html msg"}],"binops":[]},{"name":"Html.String.Extra.Attributes","comment":" Extra attributes for\n[zwilias/elm-html-string](https://package.elm-lang.org/packages/zwilias/elm-html-string/latest/). The attributes here\nare simple attributes build with\n[`Attributes.attribute`](https://package.elm-lang.org/packages/zwilias/elm-html-string/latest/Html-String-Attributes#attribute).\nThat means that we can't keep the API consistency for attributes of different types, like booleans, unfortunately.\n\n@docs async, blocking, charset, content, crossorigin, defer, httpEquiv, imagesizes, imagesrcset, integrity, nomodule, nonce, referrerpolicy, xmlns\n\n","unions":[],"aliases":[],"values":[{"name":"async","comment":" Defines the `async` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"blocking","comment":" Defines the `blocking` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"charset","comment":" Defines the `charset` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"content","comment":" Defines the `content` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"crossorigin","comment":" Defines the `crossorigin` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"defer","comment":" Defines the `defer` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"httpEquiv","comment":" Defines the `http-equiv` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"imagesizes","comment":" Defines the `imagesizes` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"imagesrcset","comment":" Defines the `imagesrcset` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"integrity","comment":" Defines the `integrity` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"nomodule","comment":" Defines the `nomodule` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"nonce","comment":" Defines the `nonce` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"referrerpolicy","comment":" Defines the `referrerpolicy` attribute.\n","type":"String.String -> Html.String.Attribute msg"},{"name":"xmlns","comment":" Defines the `xmlns` attribute.\n","type":"String.String -> Html.String.Attribute msg"}],"binops":[]},{"name":"Html.String.Extra.Document","comment":" This module attempts to expose a type-safe way of describing a full HTML document.\n\n\n# Type\n\n@docs Document\n\n\n# Creating a document\n\n@docs new, toString\n\n","unions":[{"name":"Document","comment":" The `Document` type is an [opaque type](https://sporto.github.io/elm-patterns/advanced/opaque-types.html) that tries\nto organize a way to create a full HTML document. To create a new document you need to use the `new` function.\n","args":["msg"],"cases":[]}],"aliases":[],"values":[{"name":"new","comment":" This function creates a new document. It receives a list of attributes for the root element (`<html>`), the `<head>`\nHTML node and the `<body>` HTML node. After creating your `Document`, you can convert it to a string using the\n`toString` function.\n","type":"List.List (Html.String.Attribute msg) -> Html.String.Html msg -> Html.String.Html msg -> Html.String.Extra.Document.Document msg"},{"name":"toString","comment":" This function will properly build your HTML document according to the `Document` type by converting all your nodes\nto strings. It also automatically adds the doctype to the generated string so your HTML is fully valid for browsers to\nconsume.\n","type":"Html.String.Extra.Document.Document msg -> String.String"}],"binops":[]}]