MongoDatabaseAuthServlet

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val API_APP_HEADER: String

val API_ERROR_HEADER: String

val API_KEY_HEADER: String

val BLOCKING_TIMEOUT: FiniteDuration

def acceptHeader(implicit request: HttpServletRequest): List[String]

def acceptedFormats(accepted: Symbol*): Boolean

def addMimeMapping(mime: String, extension: String): Unit

def addRoute(method: HttpMethod, transformers: Seq[RouteTransformer], action: ⇒ Any): Route

def addSessionId(uri: String)(implicit response: HttpServletResponse): String

def addStatusRoute(codes: Range, action: ⇒ Any): Unit

def after(transformers: RouteTransformer*)(fun: ⇒ Any): Unit

implicit val anyToBoolean: TypeConverter[Any, Boolean]

implicit val anyToByte: TypeConverter[Any, Byte]

implicit val anyToDouble: TypeConverter[Any, Double]

implicit val anyToFloat: TypeConverter[Any, Float]

implicit val anyToInt: TypeConverter[Any, Int]

implicit val anyToLong: TypeConverter[Any, Long]

implicit val anyToShort: TypeConverter[Any, Short]

implicit val anyToString: TypeConverter[Any, String]

final def asInstanceOf[T0]: T0

def asyncDelete(transformers: RouteTransformer*)(block: ⇒ Any): Route

def asyncGet(transformers: RouteTransformer*)(block: ⇒ Any): Route

def asyncOptions(transformers: RouteTransformer*)(block: ⇒ Any): Route

def asyncPatch(transformers: RouteTransformer*)(block: ⇒ Any): Route

def asyncPost(transformers: RouteTransformer*)(block: ⇒ Any): Route

def asyncPut(transformers: RouteTransformer*)(block: ⇒ Any): Route

def asynchronously(f: ⇒ Any): Action

implicit val authenticationStrategy: DatabaseAuthenticationStrategy[BSONObjectID]

def before(transformers: RouteTransformer*)(fun: ⇒ Any): Unit

implicit def booleanBlock2RouteMatcher(block: ⇒ Boolean): RouteMatcher

def clone(): AnyRef

var config: ConfigT

implicit def configWrapper(config: ConfigT): Config { object initParameters }

def contentType: String

def contentTypeInferrer: ContentTypeInferrer

def contentType_=(contentType: String): Unit

def contextPath: String

implicit def cookieOptions: CookieOptions

def cookies: SweetCookies

def defaultAcceptedFormats: List[Symbol]

val defaultCharacterEncoding: String

def defaultFormat: Symbol

implicit def defaultStringToSeq[T](implicit elementConverter: TypeConverter[String, T], mf: Manifest[T]): TypeConverter[String, Seq[T]]

def delete(transformers: RouteTransformer*)(action: ⇒ Any): Route

def destroy(): Unit

def doDelete(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doGet(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doHead(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

var doMethodNotAllowed: (Set[HttpMethod]) ⇒ Any

var doNotFound: Action

def doOptions(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doPost(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doPut(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doTrace(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

implicit def enrichRequest(request: HttpServletRequest): RichRequest

implicit def enrichResponse(response: HttpServletResponse): RichResponse

implicit def enrichServletContext(servletContext: ServletContext): RichServletContext

implicit def enrichSession(session: HttpSession): RichSession

def environment: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(handler: ErrorHandler): Unit

var errorHandler: ErrorHandler

def executeRoutes(): Unit

implicit def executor: ExecutionContext

def extractStatusCode(e: HaltException): Int

def finalize(): Unit

def format(implicit request: HttpServletRequest, response: HttpServletResponse): String

implicit val format: Format[ApiKey]

def formatForMimeTypes(mimeTypes: String*): Option[String]

def format_=(formatValue: String): Unit

def format_=(formatValue: Symbol): Unit

val formats: Map[String, String]

def fullUrl(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean, withSessionId: Boolean)(implicit request: HttpServletRequest, response: HttpServletResponse): String

def get(transformers: RouteTransformer*)(action: ⇒ Any): Route

final def getClass(): Class[_]

def getInitParameter(arg0: String): String

def getInitParameterNames(): Enumeration[String]

def getLastModified(arg0: HttpServletRequest): Long

def getParsedModel[T]: Option[T]

Get the model submitted via a JSON POST.

def getServletConfig(): ServletConfig

def getServletContext(): ServletContext

def getServletInfo(): String

def getServletName(): String

def halt(result: ActionResult): Nothing

def halt[T](status: Integer, body: T, headers: Map[String, String], reason: String)(implicit arg0: Manifest[T]): Nothing

def handle(request: HttpServletRequest, response: HttpServletResponse): Unit

def hashCode(): Int

def head(transformers: RouteTransformer*)(action: ⇒ Any): Route

def inferFromFormats: ContentTypeInferrer

def init(config: ServletConfig): Unit

def init(): Unit

def initParameter(name: String): Option[String]

def initialize(config: ServletConfig): Unit

def invoke(matchedRoute: MatchedRoute): Option[Any]

def isAsyncExecutable(result: Any): Boolean

def isDevelopmentMode: Boolean

def isHttps(implicit request: HttpServletRequest): Boolean

final def isInstanceOf[T0]: Boolean

def keyExists(reason: String = s"Key already exists"): Nothing

Rejects an API request with the standard 40x header and a human-friendly response message.

def keyNotFound(reason: String = s"Key provided not found"): Nothing

Rejects an API request with the standard 40x header and a human-friendly response message.

def log(arg0: String, arg1: Throwable): Unit

def log(arg0: String): Unit

val logger: Logger

implicit def lowestPriorityAny2T[T](implicit arg0: Manifest[T]): TypeConverter[Any, T]

def methodNotAllowed(f: (Set[HttpMethod]) ⇒ Any): Unit

val mimeTypes: Map[String, String]

def multiParams(implicit request: HttpServletRequest): MultiParams

def multiParams(key: String)(implicit request: HttpServletRequest): Seq[String]

final def ne(arg0: AnyRef): Boolean

def needsHttps: Boolean

def notFound(fun: ⇒ Any): Unit

final def notify(): Unit

final def notifyAll(): Unit

def onAsyncEvent(event: AsyncEvent)(thunk: ⇒ Any): Unit

def options(transformers: RouteTransformer*)(action: ⇒ Any): Route

def params(implicit request: HttpServletRequest): Params

def params(key: Symbol)(implicit request: HttpServletRequest): String

def params(key: String)(implicit request: HttpServletRequest): String

def parsedModel[T](implicit fmt: Format[T]): JsResult[T]

def pass(): Nothing

def patch(transformers: RouteTransformer*)(action: ⇒ Any): Route

implicit def pathPatternParser2RouteMatcher(pattern: PathPattern): RouteMatcher

def post(transformers: RouteTransformer*)(action: ⇒ Any): Route

def put(transformers: RouteTransformer*)(action: ⇒ Any): Route

def redirect(uri: String)(implicit request: HttpServletRequest, response: HttpServletResponse): Nothing

implicit def regex2RouteMatcher(regex: Regex): RouteMatcher

def rejectRequest(status: Integer = 401, reason: String = '>...): Nothing

Rejects an API request with the standard 40x header and a human-friendly response message.

def relativeUrl(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean)(implicit request: HttpServletRequest, response: HttpServletResponse): String

def removeRoute(method: String, route: Route): Unit

def removeRoute(method: HttpMethod, route: Route): Unit

def renderHaltException(e: HaltException): Unit

def renderJson(json: JsValue): String

def renderJson[T](model: T)(implicit fmt: Format[T]): String

def renderJson[T](model: JsResult[T])(implicit fmt: Format[T]): String

def renderJsonPipeline[T](implicit t: ClassTag[T], fmt: Format[T]): PartialFunction[Any, Any]

def renderPipeline: PartialFunction[Any, Any]

def renderResponse(actionResult: Any): Unit

def renderResponseBody(actionResult: Any): Unit

def renderUncaughtException(e: Throwable)(implicit request: HttpServletRequest, response: HttpServletResponse): Unit

implicit def request: HttpServletRequest

def requestFormat(implicit request: HttpServletRequest): String

def requestPath(implicit request: HttpServletRequest): String

def resourceNotFound(): Any

implicit def response: HttpServletResponse

def routeBasePath(implicit request: HttpServletRequest): String

lazy val routes: RouteRegistry

def runFilters(filters: Traversable[Route]): Unit

def runRoutes(routes: Traversable[Route]): Stream[Any]

implicit def safe[S, T](f: (S) ⇒ T): TypeConverter[S, T]

implicit def safeOption[S, T](f: (S) ⇒ Option[T]): TypeConverter[S, T]

implicit def scalatraContext: ScalatraContext

implicit def seqHead[T](implicit elementConverter: TypeConverter[String, T], mf: Manifest[T]): TypeConverter[Seq[String], T]

implicit def seqToSeq[T](implicit elementConverter: TypeConverter[String, T], mf: Manifest[T]): TypeConverter[Seq[String], Seq[T]]

def serveStaticResource(): Option[Any]

def serverHost(implicit request: HttpServletRequest): String

def serverPort(implicit request: HttpServletRequest): Int

def service(request: HttpServletRequest, response: HttpServletResponse): Unit

def service(arg0: ServletRequest, arg1: ServletResponse): Unit

def servletContext: ServletContext

def session(key: Symbol)(implicit request: HttpServletRequest): Any

def session(key: String)(implicit request: HttpServletRequest): Any

implicit def session(implicit request: HttpServletRequest): HttpSession

def sessionOption(implicit request: HttpServletRequest): Option[HttpSession]

def setMultiparams[S](matchedRoute: Option[MatchedRoute], originalParams: MultiParams)(implicit request: HttpServletRequest): Unit

def shouldPrettyPrintJson: Boolean

def shutdown(): Unit

def status: Int

def status_=(code: Int): Unit

implicit def string2RouteMatcher(path: String): RouteMatcher

implicit val stringToBoolean: TypeConverter[String, Boolean]

implicit val stringToByte: TypeConverter[String, Byte]

def stringToDate(format: ⇒ String): TypeConverter[String, Date]

def stringToDateFormat(format: ⇒ DateFormat): TypeConverter[String, Date]

implicit val stringToDouble: TypeConverter[String, Double]

implicit val stringToFloat: TypeConverter[String, Float]

implicit val stringToInt: TypeConverter[String, Int]

implicit val stringToLong: TypeConverter[String, Long]

implicit val stringToSelf: TypeConverter[String, String]

def stringToSeq[T](elementConverter: TypeConverter[String, T], separator: String)(implicit arg0: Manifest[T]): TypeConverter[String, Seq[T]]

implicit val stringToShort: TypeConverter[String, Short]

final def synchronized[T0](arg0: ⇒ T0): T0

implicit val tag: ClassTag[ApiKey]

def toString(): String

implicit def toTypedMultiParams(params: MultiParams): TypedMultiParams

implicit def toTypedParams(params: Params): TypedParams

def trap(codes: Range)(block: ⇒ Any): Unit

def trap(code: Int)(block: ⇒ Any): Unit

def url(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean, absolutize: Boolean, withSessionId: Boolean)(implicit request: HttpServletRequest, response: HttpServletResponse): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withRequest[A](request: HttpServletRequest)(f: ⇒ A): A

def withRequestResponse[A](request: HttpServletRequest, response: HttpServletResponse)(f: ⇒ A): A

def withResponse[A](response: HttpServletResponse)(f: ⇒ A): A

def withRouteMultiParams[S](matchedRoute: Option[MatchedRoute])(thunk: ⇒ S): S

def withinAsyncContext(context: AsyncContext)(thunk: ⇒ Any): Unit

def _request: DynamicVariable[HttpServletRequest]

def _response: DynamicVariable[HttpServletResponse]

def applicationContext: ServletContext

def asyncTimeout: Duration

def responseFormat(implicit request: HttpServletRequest, response: HttpServletResponse): String

def status(code: Int): Unit