SwaggerSupport

abstract def addSessionId(uri: String): String

abstract def applicationDescription: String

abstract def config: ConfigT

implicit abstract def configWrapper(config: ConfigT): Config

abstract val doNotFound: () ⇒ Any

implicit abstract def request: HttpServletRequest

abstract def requestPath: String

implicit abstract def response: HttpServletResponse

abstract def routeBasePath: String

implicit abstract def swagger: SwaggerEngine[_]

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

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

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val _params: Params

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

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

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

def applicationName: Option[String]

final def asInstanceOf[T0]: T0

def augmentSimpleRequest(): Unit

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

implicit def booleanBlock2RouteMatcher(block: ⇒ Boolean): RouteMatcher

def clone(): AnyRef

def contentType: String

def contentTypeInferrer: ContentTypeInferrer

def contentType_=(contentType: String): Unit

def contextPath: String

implicit def dataType2string(dt: DataType): String

val defaultCharacterEncoding: String

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

def description(f: PartialFunction[String, String]): Unit

var doMethodNotAllowed: (Set[HttpMethod]) ⇒ Any

def endpoint(value: String): (Route) ⇒ Route

def endpoints(basePath: String): List[Endpoint]

Builds the documentation for all the endpoints discovered in an API.

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 errors(value: Error*): (Route) ⇒ Route

def executeRoutes(): Unit

def finalize(): Unit

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

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

final def getClass(): Class[_]

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(req: HttpServletRequest, res: HttpServletResponse): Unit

def handlePreflightRequest(): Unit

def hashCode(): Int

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

def initialize(config: ConfigT): Unit

Initializes the kernel.

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

def isAsyncExecutable(result: Any): Boolean

def isDevelopmentMode: Boolean

def isHttps: Boolean

final def isInstanceOf[T0]: Boolean

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

implicit def modelToSwagger(cls: Class[_]): (String, Model)

def models: Map[String, Model]

def models_=(m: Map[String, Model]): Unit

def multiParams: MultiParams

final def ne(arg0: AnyRef): Boolean

def needsHttps: Boolean

def nickname(value: String): (Route) ⇒ Route

def notFound(fun: ⇒ Any): Unit

def notes(value: String): (Route) ⇒ Route

final def notify(): Unit

final def notifyAll(): Unit

def operations(route: Route, method: HttpMethod): List[Operation]

Returns a list of operations based on the given route.

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

def parameters(value: Parameter*): (Route) ⇒ Route

def params: Params

def pass(): Nothing

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

implicit def pathPatternParser2RouteMatcher(pattern: PathPattern): RouteMatcher

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

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

def redirect(uri: String): Unit

implicit def regex2RouteMatcher(regex: Regex): RouteMatcher

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

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

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

def renderHaltException(e: HaltException): Unit

def renderPipeline: RenderPipeline

def renderResponse(actionResult: Any): Unit

def renderResponseBody(actionResult: Any): Unit

def responseClass[T](implicit mf: Manifest[T]): (Route) ⇒ Route

def responseClass(value: String): (Route) ⇒ Route

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 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 serverHost: String

def serverPort: Int

def servletContext: ServletContext

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 stringToSeqBoolean: TypeConverter[String, Seq[Boolean]]

implicit val stringToSeqByte: TypeConverter[String, Seq[Byte]]

implicit val stringToSeqDouble: TypeConverter[String, Seq[Double]]

implicit val stringToSeqFloat: TypeConverter[String, Seq[Float]]

implicit val stringToSeqInt: TypeConverter[String, Seq[Int]]

implicit val stringToSeqLong: TypeConverter[String, Seq[Long]]

implicit val stringToSeqShort: TypeConverter[String, Seq[Short]]

implicit val stringToSeqString: TypeConverter[String, Seq[String]]

implicit val stringToShort: TypeConverter[String, Short]

def summary(value: String): (Route) ⇒ Route

def swaggerDefaultErrors: List[Error]

def swaggerMeta(s: Symbol, v: Any): (Route) ⇒ Route

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

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): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def applicationContext: ServletContext

def status(code: Int): Unit