FreeMarkerTemplateEngineFeature

abstract val doNotFound: Action

abstract def requestPath(implicit ctx: SkinnyContext): String

abstract def routeBasePath(implicit ctx: SkinnyContext): String

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

def acceptedFormats(accepted: Symbol*): Boolean

val actionDefinitions: ArrayBuffer[ActionDefinition]

def addActionDefinition(actionDef: ActionDefinition): Unit

def addErrorFilter(handler: ErrorHandler): Unit

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

def addParam(name: String, value: Any)(implicit ctx: SkinnyContext): Unit

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

def afterAction(only: Seq[Symbol], except: Seq[Symbol])(action: ⇒ Any): Unit

def afterFilter(only: Seq[Symbol], except: Seq[Symbol])(action: ⇒ Any): Unit

implicit val anyToBoolean: micro.implicits.TypeConverter[Any, Boolean]

implicit val anyToByte: micro.implicits.TypeConverter[Any, Byte]

implicit val anyToDouble: micro.implicits.TypeConverter[Any, Double]

implicit val anyToFloat: micro.implicits.TypeConverter[Any, Float]

implicit val anyToInt: micro.implicits.TypeConverter[Any, Int]

implicit val anyToLong: micro.implicits.TypeConverter[Any, Long]

implicit val anyToShort: micro.implicits.TypeConverter[Any, Short]

implicit val anyToString: micro.implicits.TypeConverter[Any, String]

final def asInstanceOf[T0]: T0

def asJValue[T](obj: T)(implicit writer: Writer[T]): JValue

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

def beforeAction(only: Seq[Symbol], except: Seq[Symbol])(action: ⇒ Any): Unit

def beforeFilter(only: Seq[Symbol], except: Seq[Symbol])(action: ⇒ Any): Unit

implicit def booleanBlock2RouteMatcher(block: ⇒ Boolean): RouteMatcher

lazy val charset: Option[String]

def clone(): AnyRef

def compact(value: JValue): String

var config: ConfigT

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

def contentType(implicit ctx: SkinnyContext): String

def contentTypeInferrer: ContentTypeInferrer

def contentType_=(contentType: String)(implicit ctx: SkinnyContext): Unit

def context: SkinnyContext

def contextPath: String

implicit def convertParamsToStrongParameters(params: micro.Params): StrongParameters

implicit def convertRouteToRichRoute(route: Route)(implicit controller: SkinnyControllerCommonBase): RichRoute

implicit def cookieOptions(implicit ctx: SkinnyContext): CookieOptions

def cookies(implicit ctx: SkinnyContext): SweetCookies

def createI18n()(implicit locale: Locale): I18n

def currentActionName(implicit cxt: SkinnyContext): Option[Symbol]

def currentErrorHandler: ErrorHandler

def currentLocale(implicit ctx: SkinnyContext): Option[Locale]

def defaultAcceptedFormats: List[Symbol]

val defaultCharacterEncoding: String

def defaultFormat: Symbol

def defaultLocale: Option[Locale]

def defaultObjectMapper: ObjectMapper

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

def detectTooManyErrorFilterRegistrationAsAnErrorAtSkinnyMicroBase: Boolean

implicit def enrichRequest(request: HttpServletRequest): RichRequest

implicit def enrichResponse(response: HttpServletResponse): RichResponse

implicit def enrichServletContext(servletContext: javax.servlet.ServletContext): RichServletContext

implicit def enrichSession(session: HttpSession): RichHttpServletSession

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(handler: ErrorHandler): Unit

def errorMessages(implicit ctx: SkinnyContext): Seq[String]

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

implicit def executionContext: ExecutionContext

def finalize(): Unit

def formMultiParams(implicit ctx: SkinnyContext): micro.MultiParams

def formParams(implicit ctx: SkinnyContext): micro.Params

def format(implicit ctx: SkinnyContext): String

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

def format_=(formatValue: String)(implicit ctx: SkinnyContext): Unit

val formats: Map[String, String]

lazy val freeMarker: FreeMarker

FreeMarker Scala wrapper.

lazy val freeMarkerExtension: String

def fromJSONString[A](json: String, underscoreKeys: Boolean, asIs: Boolean)(implicit mf: Manifest[A]): Try[A]

def fromJSONStringAsIs[A](json: String)(implicit mf: Manifest[A]): Try[A]

def fromJSONStringToJValue(json: String, underscoreKeys: Boolean, asIs: Boolean): Try[JValue]

def fromJValue[T](json: JValue)(implicit reader: Reader[T]): T

def fullUrl(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean, withSessionId: Boolean)(implicit ctx: SkinnyContext): String

final def getClass(): Class[_]

def getFromRequestScope[A](key: String)(implicit ctx: SkinnyContext): Option[A]

def halt(result: ActionResult): Nothing

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

def haltWithBody[A](httpStatus: Int)(implicit ctx: SkinnyContext, format: Format): A

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

def hashCode(): Int

def inferFromFormats: ContentTypeInferrer

def infoTimeLoggingEnabled: Boolean

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

def initialize(config: ConfigT): Unit

def initializeRequestScopeAttributes(implicit ctx: SkinnyContext): Any

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

def isAsyncExecutable(result: Any): Boolean

def isDevelopment(): Boolean

final def isInstanceOf[T0]: Boolean

def isProduction(): Boolean

def isStaging(): Boolean

def isTest(): Boolean

implicit val jsonFormats: Formats

def keyAndErrorMessages(implicit ctx: SkinnyContext): Map[String, Seq[String]]

def logger: Logger

def loggerName: String

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

def maxDurationToAwaitAsyncFilters: Duration

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

val mimeTypes: Map[String, String]

def mount(ctx: javax.servlet.ServletContext): Unit

def multiParams(key: String)(implicit ctx: SkinnyContext): Seq[String]

def multiParams(implicit ctx: SkinnyContext): micro.MultiParams

final def ne(arg0: AnyRef): Boolean

def notFound(fun: ⇒ Any): Unit

final def notify(): Unit

final def notifyAll(): Unit

def params(implicit ctx: SkinnyContext): micro.Params

def params(key: Symbol)(implicit ctx: SkinnyContext): String

def params(key: String)(implicit ctx: SkinnyContext): String

def pass(): Nothing

implicit def pathPatternParser2RouteMatcher(pattern: PathPattern): RouteMatcher

def prefixForJSONVulnerabilityProtection: String

def queryMultiParams(implicit ctx: SkinnyContext): micro.MultiParams

def queryParams(implicit ctx: SkinnyContext): micro.Params

def redirect(uri: String)(implicit ctx: SkinnyContext): ActionResult

def redirect301(location: String, headers: Map[String, String])(implicit ctx: SkinnyContext): ActionResult

def redirect302(location: String, headers: Map[String, String])(implicit ctx: SkinnyContext): ActionResult

def redirect303(location: String, headers: Map[String, String])(implicit ctx: SkinnyContext): ActionResult

implicit def regex2RouteMatcher(regex: Regex): RouteMatcher

def relativeUrl(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean)(implicit ctx: SkinnyContext): String

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

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

def render(path: String)(implicit ctx: SkinnyContext, format: Format): String

def renderResponse(actionResult: Any)(implicit ctx: SkinnyContext): Unit

def renderResponseBody(actionResult: Any)(implicit ctx: SkinnyContext): Unit

def renderUncaughtException(e: Throwable)(implicit ctx: SkinnyContext): Unit

def renderWithFormat(entity: Any)(implicit format: micro.Format): String

def renderWithTemplate(path: String)(implicit ctx: SkinnyContext, format: Format = Format.HTML): String

def request(implicit ctx: SkinnyContext): HttpServletRequest

def requestFormat(implicit ctx: SkinnyContext): String

def requestScope(keyAndValues: Seq[(String, Any)])(implicit ctx: SkinnyContext): RequestScopeFeature

def requestScope(keyAndValue: (String, Any))(implicit ctx: SkinnyContext): RequestScopeFeature

def requestScope(implicit ctx: SkinnyContext): Map[String, Any]

def respondTo: Seq[micro.Format]

def response(implicit ctx: SkinnyContext): HttpServletResponse

def responseAsJSON(entity: Any, charset: Option[String], prettify: Boolean, underscoreKeys: Boolean)(implicit ctx: SkinnyContext): String

val routes: RouteRegistry

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

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

lazy val sbtProjectPath: Option[String]

def sensitiveParameterNames: Seq[String]

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

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

def serverAuthority(implicit ctx: SkinnyContext): String

def serverHost(implicit ctx: SkinnyContext): String

def serverPort(implicit ctx: SkinnyContext): Int

implicit def servletContext: javax.servlet.ServletContext

def session(key: Symbol)(implicit ctx: SkinnyContext): Any

def session(key: String)(implicit ctx: SkinnyContext): Any

implicit def session(implicit ctx: SkinnyContext): HttpSession

def sessionLocaleKey: String

def sessionOption(implicit ctx: SkinnyContext): Option[HttpSession]

def set(keyAndValues: Seq[(String, Any)])(implicit ctx: SkinnyContext): RequestScopeFeature

def set(keyAndValue: (String, Any))(implicit ctx: SkinnyContext): RequestScopeFeature

def setAsParams(model: Any)(implicit ctx: SkinnyContext): Unit

def setContentTypeIfAbsent()(implicit format: micro.Format): Unit

def setCurrentLocale(locale: String)(implicit ctx: SkinnyContext): Unit

def setI18n(implicit ctx: SkinnyContext): RequestScopeFeature

def setMultiparams[S](matchedRoute: Option[MatchedRoute], originalParams: micro.MultiParams)(implicit ctx: SkinnyContext): Unit

def setParams(implicit ctx: SkinnyContext): Unit

def setParamsToRequestScope(implicit ctx: SkinnyContext): Unit

def shutdown(): Unit

def skinnyContext(implicit ctx: javax.servlet.ServletContext): SkinnyContext

def skinnyEnv: Option[String]

lazy val skinnyErrorFilters: TrieMap[RenderingRequired, Seq[ErrorHandler]]

implicit def skinnyValidatorSafe[S, T](f: (S) ⇒ T): ParamValueTypeConverter[S, T]

implicit def skinnyValidatorSafeOption[S, T](f: (S) ⇒ Option[T]): ParamValueTypeConverter[S, T]

implicit def skinnyValidatorSeqHead[T](implicit elementConverter: ParamValueTypeConverter[String, T], mf: Manifest[T]): ParamValueTypeConverter[Seq[String], T]

implicit def skinnyValidatorSeqToSeq[T](implicit elementConverter: ParamValueTypeConverter[String, T], mf: Manifest[T]): ParamValueTypeConverter[Seq[String], Seq[T]]

implicit val skinnyValidatorStringToBoolean: ParamValueTypeConverter[String, Boolean]

implicit val skinnyValidatorStringToByte: ParamValueTypeConverter[String, Byte]

def skinnyValidatorStringToDate(format: ⇒ String): ParamValueTypeConverter[String, Date]

def skinnyValidatorStringToDateFormat(format: ⇒ DateFormat): ParamValueTypeConverter[String, Date]

implicit val skinnyValidatorStringToDouble: ParamValueTypeConverter[String, Double]

implicit val skinnyValidatorStringToFloat: ParamValueTypeConverter[String, Float]

implicit val skinnyValidatorStringToInt: ParamValueTypeConverter[String, Int]

implicit val skinnyValidatorStringToLong: ParamValueTypeConverter[String, Long]

implicit val skinnyValidatorStringToSelf: ParamValueTypeConverter[String, String]

def skinnyValidatorStringToSeq[T](elementConverter: ParamValueTypeConverter[String, T], separator: String)(implicit arg0: Manifest[T]): ParamValueTypeConverter[String, Seq[T]]

implicit val skinnyValidatorStringToShort: ParamValueTypeConverter[String, Short]

implicit def skinnyValidator_defaultStringToSeq[T](implicit elementConverter: ParamValueTypeConverter[String, T], mf: Manifest[T]): ParamValueTypeConverter[String, Seq[T]]

def skipHaltingWhenRedirection: Boolean

def stackTraceDepthForTimeLogging: Int

def status(implicit ctx: SkinnyContext): Int

def status_=(code: Int)(implicit ctx: SkinnyContext): Unit

implicit def string2RouteMatcher(path: String): RouteMatcher

implicit val stringToBoolean: micro.implicits.TypeConverter[String, Boolean]

implicit val stringToByte: micro.implicits.TypeConverter[String, Byte]

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

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

implicit val stringToDouble: micro.implicits.TypeConverter[String, Double]

implicit val stringToFloat: micro.implicits.TypeConverter[String, Float]

implicit val stringToInt: micro.implicits.TypeConverter[String, Int]

implicit val stringToLong: micro.implicits.TypeConverter[String, Long]

implicit def stringToRicherString(s: String): RicherString

implicit val stringToSelf: micro.implicits.TypeConverter[String, String]

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

implicit val stringToShort: micro.implicits.TypeConverter[String, Short]

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

def templateExists(path: String)(implicit format: Format = Format.HTML): Boolean

def templatePath(path: String)(implicit format: Format = Format.HTML): String

def templatePaths(path: String)(implicit format: Format = Format.HTML): List[String]

def toJSON(v: Any): JValue

def toJSONString(v: Any, underscoreKeys: Boolean): String

def toJSONStringAsIs(v: Any): String

def toPrettyJSONString(v: Any, underscoreKeys: Boolean): String

def toPrettyJSONStringAsIs(v: Any): String

def toSnakeCase(s: String): String

def toString(): String

implicit def toTypedMultiParams(params: micro.MultiParams): TypedMultiParams

implicit def toTypedParams(params: micro.Params): TypedParams

def unstableAccessValidationEnabled: Boolean

def url(route: Route, params: Map[String, String], splats: Iterable[String])(implicit ctx: SkinnyContext): String

def url(route: Route, splat: String, moreSplats: String*)(implicit ctx: SkinnyContext): String

def url(route: Route, params: (String, String)*)(implicit ctx: SkinnyContext): String

def url(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean, absolutize: Boolean)(implicit ctx: SkinnyContext): String

def useJSONVulnerabilityProtection: Boolean

def useMostlyStableHttpSession: Boolean

def useSnakeCasedParamKeys: Boolean

def useUnderscoreKeysForJSON: Boolean

def validation(params: Params, validations: NewValidation*)(implicit locale: Locale): MapValidator

def validationWithParams(validations: NewValidation*)(implicit locale: Locale): MapValidator

def validationWithParamsAndPrefix(prefix: String, params: Params, validations: NewValidation*)(implicit locale: Locale): MapValidator

def validationWithPrefix(params: Params, prefix: String, validations: NewValidation*)(implicit ctx: SkinnyContext): MapValidator

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warnElapsedTime[A](millis: Long, additionalLines: ⇒ Seq[String])(action: ⇒ A): A

def warnElapsedTimeWithRequest[A](millis: Long, additionalLines: Seq[String])(action: ⇒ A)(implicit context: SkinnyContext): A

def withFormat[A](format: micro.Format)(action: ⇒ A): A

def withOutputStream(f: (ServletOutputStream) ⇒ Unit)(implicit ctx: micro.Context): 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 writeChunk(chunk: Array[Byte])(implicit ctx: micro.Context): Unit

def xmlItemName: String

def xmlRootName: String

def responseFormat(implicit ctx: SkinnyContext): String