RouteTest

abstract def createTestRouteResultAsync(request: HttpRequest, result: Future[RouteResult]): TestRouteResult

implicit abstract def materializer: Materializer

implicit abstract def system: ActorSystem

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (RouteTest, B)

final def ==(arg0: Any): Boolean

def WS(uri: Uri, clientSideHandler: Flow[Message, Message, Any], materializer: Materializer, subprotocols: List[String]): HttpRequest

def WS(uri: Uri, clientSideHandler: Flow[Message, Message, Any], materializer: Materializer): HttpRequest

final def asInstanceOf[T0]: T0

def authenticateBasic[T](realm: String, authenticator: Function[Optional[ProvidedCredentials], Optional[T]], inner: Function[T, Route]): Route

def authenticateBasicAsync[T](realm: String, authenticator: Function[Optional[ProvidedCredentials], CompletionStage[Optional[T]]], inner: Function[T, Route]): Route

def authenticateBasicAsyncOptional[T](realm: String, authenticator: Function[Optional[ProvidedCredentials], CompletionStage[Optional[T]]], inner: Function[Optional[T], Route]): Route

def authenticateBasicOptional[T](realm: String, authenticator: Function[Optional[ProvidedCredentials], Optional[T]], inner: Function[Optional[T], Route]): Route

def authenticateBasicPF[T](realm: String, authenticator: PartialFunction[Optional[ProvidedCredentials], T], inner: Function[T, Route]): Route

def authenticateBasicPFAsync[T](realm: String, authenticator: PartialFunction[Optional[ProvidedCredentials], CompletionStage[T]], inner: Function[T, Route]): Route

def authenticateOAuth2[T](realm: String, authenticator: Function[Optional[ProvidedCredentials], Optional[T]], inner: Function[T, Route]): Route

def authenticateOAuth2Async[T](realm: String, authenticator: Function[Optional[ProvidedCredentials], CompletionStage[Optional[T]]], inner: Function[T, Route]): Route

def authenticateOAuth2AsyncOptional[T](realm: String, authenticator: Function[Optional[ProvidedCredentials], CompletionStage[Optional[T]]], inner: Function[Optional[T], Route]): Route

def authenticateOAuth2Optional[T](realm: String, authenticator: Function[Optional[ProvidedCredentials], Optional[T]], inner: Function[Optional[T], Route]): Route

def authenticateOrRejectWithChallenge[C <: HttpCredentials, T](c: Class[C], authenticator: Function[Optional[C], CompletionStage[Either[HttpChallenge, T]]], inner: Function[T, Route]): Route

def authenticateOrRejectWithChallenge[T](authenticator: Function[Optional[HttpCredentials], CompletionStage[Either[HttpChallenge, T]]], inner: Function[T, Route]): Route

def authorize(check: Supplier[Boolean], inner: Supplier[Route]): Route

def authorizeAsync(check: Supplier[CompletionStage[Boolean]], inner: Supplier[Route]): Route

def authorizeAsyncWithRequestContext(check: Function[RequestContext, CompletionStage[Boolean]], inner: Supplier[Route]): Route

def authorizeWithRequestContext(check: Function[RequestContext, Boolean], inner: Supplier[Route]): Route

def awaitDuration: FiniteDuration

def cancelRejection(rejection: Rejection, inner: Supplier[Route]): Route

def cancelRejections(filter: Predicate[Rejection], inner: Supplier[Route]): Route

def cancelRejections(classes: Iterable[Class[_]], inner: Supplier[Route]): Route

def checkSameOrigin(allowed: HttpOriginRange, inner: Supplier[Route]): Route

def clone(): AnyRef

def complete(entity: RequestEntity): RouteAdapter

def complete(entity: ResponseEntity): RouteAdapter

def complete(headers: Iterable[HttpHeader], entity: RequestEntity): RouteAdapter

def complete(headers: Iterable[HttpHeader], entity: ResponseEntity): RouteAdapter

def complete[T](headers: Iterable[HttpHeader], value: T, marshaller: Marshaller[T, RequestEntity]): RouteAdapter

def complete(status: StatusCode, entity: String): RouteAdapter

def complete(status: StatusCode, entity: RequestEntity): RouteAdapter

def complete(status: StatusCode, entity: ResponseEntity): RouteAdapter

def complete[T](status: StatusCode, value: T, marshaller: Marshaller[T, RequestEntity]): RouteAdapter

def complete(status: StatusCode, headers: Iterable[HttpHeader], entity: RequestEntity): RouteAdapter

def complete(status: StatusCode, headers: Iterable[HttpHeader], entity: ResponseEntity): RouteAdapter

def complete[T](status: StatusCode, headers: Iterable[HttpHeader], value: T, marshaller: Marshaller[T, RequestEntity]): RouteAdapter

def complete[T](value: T, marshaller: Marshaller[T, HttpResponse]): RouteAdapter

def complete(status: StatusCode): Route

def complete(response: HttpResponse): Route

def complete(body: String): Route

def completeOK[T](value: T, marshaller: Marshaller[T, RequestEntity]): RouteAdapter

def completeOKWithFuture[T](value: CompletionStage[T], marshaller: Marshaller[T, RequestEntity]): RouteAdapter

def completeOKWithFuture(value: CompletionStage[RequestEntity]): RouteAdapter

def completeOKWithFuture[T](value: Future[T], marshaller: Marshaller[T, RequestEntity]): RouteAdapter

def completeOKWithFutureString(value: CompletionStage[String]): RouteAdapter

def completeOKWithFutureString(value: Future[String]): RouteAdapter

def completeOKWithSource[T, M](source: Source[T, M])(implicit m: Marshaller[T, RequestEntity], support: EntityStreamingSupport): Route

def completeOrRecoverWith[T](f: Supplier[CompletionStage[T]], marshaller: Marshaller[T, RequestEntity], inner: Function[Throwable, Route]): Route

def completeWith[T](marshaller: Marshaller[T, _ <: HttpResponse], inner: Consumer[Consumer[T]]): Route

def completeWithFuture[T](value: CompletionStage[T], marshaller: Marshaller[T, HttpResponse]): RouteAdapter

def completeWithFuture(value: CompletionStage[HttpResponse]): RouteAdapter

def completeWithFuture[T](value: Future[T], marshaller: Marshaller[T, HttpResponse]): RouteAdapter

def completeWithFutureResponse(value: Future[HttpResponse]): RouteAdapter

def completeWithFutureStatus(status: CompletionStage[StatusCode]): Route

def completeWithFutureStatus(status: Future[StatusCode]): Route

def completeWithSource[T, M](source: Source[T, M])(implicit m: Marshaller[T, ByteString], support: EntityStreamingSupport): Route

def conditional(eTag: Optional[EntityTag], lastModified: Optional[DateTime], inner: Supplier[Route]): Route

def conditional(eTag: EntityTag, lastModified: DateTime, inner: Supplier[Route]): Route

def conditional(lastModified: DateTime, inner: Supplier[Route]): Route

def conditional(eTag: EntityTag, inner: Supplier[Route]): Route

def cookie(name: String, inner: Function[HttpCookiePair, Route]): Route

def createTestRouteResult(request: HttpRequest, result: RouteResult): TestRouteResult

def decodeRequest(inner: Supplier[Route]): Route

def decodeRequestWith(coders: Iterable[Coder], inner: Supplier[Route]): Route

def decodeRequestWith(coder: Coder, inner: Supplier[Route]): Route

def defaultContentTypeResolver: ContentTypeResolver

def defaultDirectoryRenderer: DirectoryRenderer

def defaultHostInfo: DefaultHostInfo

def delete(inner: Supplier[Route]): Route

def deleteCookie(name: String, domain: String, path: String, inner: Supplier[Route]): Route

def deleteCookie(name: String, domain: String, inner: Supplier[Route]): Route

def deleteCookie(name: String, inner: Supplier[Route]): Route

def deleteCookie(cookies: Iterable[HttpCookie], inner: Supplier[Route]): Route

def deleteCookie(cookie: HttpCookie, inner: Supplier[Route]): Route

def encodeResponse(inner: Supplier[Route]): Route

def encodeResponseWith(coders: Iterable[Coder], inner: Supplier[Route]): Route

def ensuring(cond: (RouteTest) ⇒ Boolean, msg: ⇒ Any): RouteTest

def ensuring(cond: (RouteTest) ⇒ Boolean): RouteTest

def ensuring(cond: Boolean, msg: ⇒ Any): RouteTest

def ensuring(cond: Boolean): RouteTest

def entity[T](unmarshaller: Unmarshaller[_ >: HttpEntity, T], inner: Function[T, Route]): Route

def entityAsSourceOf[T](um: Unmarshaller[ByteString, T], support: EntityStreamingSupport, inner: Function[Source[T, NotUsed], Route]): Route

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def executionContext: ExecutionContextExecutor

def extract[T](extract: Function[RequestContext, T], inner: Function[T, Route]): Route

def extractActorSystem(inner: Function[ActorSystem, Route]): Route

def extractClientIP(inner: Function[RemoteAddress, Route]): Route

def extractCredentials(inner: Function[Optional[HttpCredentials], Route]): Route

def extractDataBytes(inner: Function[Source[ByteString, Any], Route]): RouteAdapter

def extractEntity(inner: Function[RequestEntity, Route]): Route

def extractExecutionContext(inner: Function[ExecutionContextExecutor, Route]): Route

def extractHost(inner: Function[String, Route]): Route

def extractLog(inner: Function[LoggingAdapter, Route]): Route

def extractMatchedPath(inner: Function[String, Route]): RouteAdapter

def extractMaterializer(inner: Function[Materializer, Route]): Route

def extractMethod(inner: Function[HttpMethod, Route]): RouteAdapter

def extractOfferedWsProtocols(inner: Function[List[String], Route]): Route

def extractParserSettings(inner: Function[ParserSettings, Route]): RouteAdapter

def extractRequest(inner: Function[HttpRequest, Route]): RouteAdapter

def extractRequestContext(inner: Function[RequestContext, Route]): RouteAdapter

def extractRequestEntity(inner: Function[RequestEntity, Route]): Route

def extractScheme(inner: Function[String, Route]): Route

def extractSettings(inner: Function[RoutingSettings, Route]): RouteAdapter

def extractStrictEntity(timeout: FiniteDuration, inner: Function[Strict, Route]): Route

def extractUnmatchedPath(inner: Function[String, Route]): RouteAdapter

def extractUpgradeToWebSocket(inner: Function[UpgradeToWebSocket, Route]): Route

def extractUri(inner: Function[Uri, Route]): RouteAdapter

def failWith(error: Throwable): Route

def fileUpload(fieldName: String, inner: BiFunction[FileInfo, Source[ByteString, Any], Route]): Route

def fileUploadAll(fieldName: String, inner: Function[List[Entry[FileInfo, Source[ByteString, Any]]], Route]): Route

def finalize(): Unit

def formField[T](t: Unmarshaller[String, T], name: String, inner: Function[T, Route]): Route

def formField(name: String, inner: Function[String, Route]): Route

def formFieldList(inner: Function[List[Entry[String, String]], Route]): Route

def formFieldList[T](t: Unmarshaller[String, T], name: String, inner: Function[List[T], Route]): Route

def formFieldList(name: String, inner: Function[List[String], Route]): Route

def formFieldMap(inner: Function[Map[String, String], Route]): Route

def formFieldMultiMap(inner: Function[Map[String, List[String]], Route]): Route

def formFieldOptional[T](t: Unmarshaller[String, T], name: String, inner: Function[Optional[T], Route]): Route

def formFieldOptional(name: String, inner: Function[Optional[String], Route]): Route

def formatted(fmtstr: String): String

def get(inner: Supplier[Route]): Route

final def getClass(): Class[_]

def getFromBrowseableDirectories(directories: String*): Route

def getFromBrowseableDirectories(directories: Iterable[String], resolver: ContentTypeResolver): Route

def getFromBrowseableDirectories(directories: Iterable[String], renderer: DirectoryRenderer): Route

def getFromBrowseableDirectories(directories: Iterable[String], renderer: DirectoryRenderer, resolver: ContentTypeResolver): Route

def getFromBrowseableDirectory(directory: String): Route

def getFromBrowseableDirectory(directory: String, resolver: ContentTypeResolver): Route

def getFromBrowseableDirectory(directory: String, renderer: DirectoryRenderer): Route

def getFromBrowseableDirectory(directory: String, renderer: DirectoryRenderer, resolver: ContentTypeResolver): Route

def getFromDirectory(directoryPath: String, resolver: ContentTypeResolver): Route

def getFromDirectory(directoryPath: String): Route

def getFromFile(file: String, resolver: ContentTypeResolver): Route

def getFromFile(file: String): Route

def getFromFile(file: File, contentType: ContentType): Route

def getFromFile(file: File, resolver: ContentTypeResolver): Route

def getFromFile(file: File): Route

def getFromResource(path: String, contentType: ContentType, classLoader: ClassLoader): Route

def getFromResource(path: String, contentType: ContentType): Route

def getFromResource(path: String, resolver: ContentTypeResolver): Route

def getFromResource(path: String): Route

def getFromResourceDirectory(directoryName: String, resolver: ContentTypeResolver, classLoader: ClassLoader): Route

def getFromResourceDirectory(directoryName: String, resolver: ContentTypeResolver): Route

def getFromResourceDirectory(directoryName: String, classLoader: ClassLoader): Route

def getFromResourceDirectory(directoryName: String): Route

def handleExceptions(handler: ExceptionHandler, inner: Supplier[Route]): RouteAdapter

def handleRejections(handler: RejectionHandler, inner: Supplier[Route]): RouteAdapter

def handleWebSocketMessages[T](handler: Flow[Message, Message, T]): Route

def handleWebSocketMessagesForOptionalProtocol[T](handler: Flow[Message, Message, T], subprotocol: Optional[String]): Route

def handleWebSocketMessagesForProtocol[T](handler: Flow[Message, Message, T], subprotocol: String): Route

def handleWith[T, R](unmarshaller: Unmarshaller[_ >: HttpEntity, T], marshaller: Marshaller[R, _ <: HttpResponse], inner: Function[T, R]): Route

def hashCode(): Int

def head(inner: Supplier[Route]): Route

def headerValue[T](f: Function[HttpHeader, Optional[T]], inner: Function[T, Route]): RouteAdapter

def headerValueByName(headerName: String, inner: Function[String, Route]): RouteAdapter

def headerValueByType[T <: HttpHeader](t: Class[T], inner: Function[T, Route]): RouteAdapter

def headerValuePF[T](pf: PartialFunction[HttpHeader, T], inner: Function[T, Route]): RouteAdapter

def host(regex: Pattern, inner: Function[String, Route]): Route

def host(predicate: Predicate[String], inner: Supplier[Route]): Route

def host(hostName: String, inner: Supplier[Route]): Route

def host(hostNames: Iterable[String], inner: Supplier[Route]): Route

def ignoreTrailingSlash(inner: Supplier[Route]): Route

final def isInstanceOf[T0]: Boolean

def listDirectoryContents(directoryRenderer: DirectoryRenderer, directories: String*): Route

def listDirectoryContents(directories: String*): Route

def logRequest(show: Function[HttpRequest, LogEntry], inner: Supplier[Route]): Route

def logRequest(marker: String, level: LogLevel, inner: Supplier[Route]): Route

def logRequest(marker: String, inner: Supplier[Route]): Route

def logRequestResult(showSuccess: BiFunction[HttpRequest, HttpResponse, LogEntry], showRejection: BiFunction[HttpRequest, List[Rejection], LogEntry], inner: Supplier[Route]): RouteAdapter

def logRequestResultOptional(showSuccess: BiFunction[HttpRequest, HttpResponse, Optional[LogEntry]], showRejection: BiFunction[HttpRequest, List[Rejection], Optional[LogEntry]], inner: Supplier[Route]): RouteAdapter

def logResult(showSuccess: Function[HttpResponse, LogEntry], showRejection: Function[List[Rejection], LogEntry], inner: Supplier[Route]): RouteAdapter

def logResult(marker: String, level: LogLevel, inner: Supplier[Route]): Route

def logResult(marker: String, inner: Supplier[Route]): Route

def mapInnerRoute(f: Function[Route, Route], inner: Supplier[Route]): Route

def mapRejections(f: Function[List[Rejection], List[Rejection]], inner: Supplier[Route]): Route

def mapRequest(f: Function[HttpRequest, HttpRequest], inner: Supplier[Route]): Route

def mapRequestContext(f: Function[RequestContext, RequestContext], inner: Supplier[Route]): Route

def mapResponse(f: Function[HttpResponse, HttpResponse], inner: Supplier[Route]): Route

def mapResponseEntity(f: Function[ResponseEntity, ResponseEntity], inner: Supplier[Route]): Route

def mapResponseHeaders(f: Function[List[HttpHeader], List[HttpHeader]], inner: Supplier[Route]): Route

def mapRouteResult(f: Function[RouteResult, RouteResult], inner: Supplier[Route]): Route

def mapRouteResultFuture(f: Function[CompletionStage[RouteResult], CompletionStage[RouteResult]], inner: Supplier[Route]): Route

def mapRouteResultPF(f: PartialFunction[RouteResult, RouteResult], inner: Supplier[Route]): Route

def mapRouteResultWith(f: Function[RouteResult, CompletionStage[RouteResult]], inner: Supplier[Route]): Route

def mapRouteResultWithPF(f: PartialFunction[RouteResult, CompletionStage[RouteResult]], inner: Supplier[Route]): Route

def mapSettings(f: Function[RoutingSettings, RoutingSettings], inner: Supplier[Route]): Route

def mapUnmatchedPath(f: Function[String, String], inner: Supplier[Route]): Route

def method(method: HttpMethod, inner: Supplier[Route]): Route

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onComplete[T](cs: CompletionStage[T], inner: Function[Try[T], Route]): RouteAdapter

def onComplete[T](f: Supplier[CompletionStage[T]], inner: Function[Try[T], Route]): RouteAdapter

def onCompleteWithBreaker[T](breaker: CircuitBreaker, f: Supplier[CompletionStage[T]], inner: Function[Try[T], Route]): RouteAdapter

def onSuccess[T](cs: CompletionStage[T], inner: Function[T, Route]): RouteAdapter

def onSuccess[T](f: Supplier[CompletionStage[T]], inner: Function[T, Route]): RouteAdapter

def optionalCookie(name: String, inner: Function[Optional[HttpCookiePair], Route]): Route

def optionalHeaderValue[T](f: Function[HttpHeader, Optional[T]], inner: Function[Optional[T], Route]): RouteAdapter

def optionalHeaderValueByName(headerName: String, inner: Function[Optional[String], Route]): RouteAdapter

def optionalHeaderValueByType[T <: HttpHeader](t: Class[T], inner: Function[Optional[T], Route]): RouteAdapter

def optionalHeaderValuePF[T](pf: PartialFunction[HttpHeader, T], inner: Function[Optional[T], Route]): RouteAdapter

def options(inner: Supplier[Route]): Route

def overrideMethodWithParameter(paramName: String, inner: Supplier[Route]): Route

def parameter[T](t: Unmarshaller[String, T], name: String, inner: Function[T, Route]): Route

def parameter(name: String, inner: Function[String, Route]): Route

def parameterList(inner: Function[List[Entry[String, String]], Route]): Route

def parameterList[T](t: Unmarshaller[String, T], name: String, inner: Function[List[T], Route]): Route

def parameterList(name: String, inner: Function[List[String], Route]): Route

def parameterMap(inner: Function[Map[String, String], Route]): Route

def parameterMultiMap(inner: Function[Map[String, List[String]], Route]): Route

def parameterOptional[T](t: Unmarshaller[String, T], name: String, inner: Function[Optional[T], Route]): Route

def parameterOptional(name: String, inner: Function[Optional[String], Route]): Route

def parameterOrDefault[T](t: Unmarshaller[String, T], defaultValue: T, name: String, inner: Function[T, Route]): Route

def pass(inner: Supplier[Route]): Route

def patch(inner: Supplier[Route]): Route

def path[T](t: Unmarshaller[String, T], inner: Function[T, Route]): Route

def path[T1, T2](p: PathMatcher2[T1, T2], inner: BiFunction[T1, T2, Route]): Route

def path[T](p: PathMatcher1[T], inner: Function[T, Route]): Route

def path(p: PathMatcher0, inner: Supplier[Route]): Route

def path(inner: Function[String, Route]): Route

def path(segment: String, inner: Supplier[Route]): Route

def pathEnd(inner: Supplier[Route]): Route

def pathEndOrSingleSlash(inner: Supplier[Route]): Route

def pathPrefix[T](t: Unmarshaller[String, T], inner: Function[T, Route]): Route

def pathPrefix[T1, T2](p: PathMatcher2[T1, T2], inner: BiFunction[T1, T2, Route]): Route

def pathPrefix[T](p: PathMatcher1[T], inner: Function[T, Route]): Route

def pathPrefix(p: PathMatcher0, inner: Supplier[Route]): Route

def pathPrefix(inner: Function[String, Route]): Route

def pathPrefix(segment: String, inner: Supplier[Route]): Route

def pathPrefixTest[T1, T2](pm: PathMatcher2[T1, T2], inner: BiFunction[T1, T2, Route]): Route

def pathPrefixTest[T1](pm: PathMatcher1[T1], inner: Function[T1, Route]): Route

def pathPrefixTest(pm: PathMatcher0, inner: Supplier[Route]): Route

def pathPrefixTest(segment: String, inner: Supplier[Route]): Route

def pathSingleSlash(inner: Supplier[Route]): Route

def pathSuffix[T1, T2](pm: PathMatcher2[T1, T2], inner: BiFunction[T1, T2, Route]): Route

def pathSuffix[T1](pm: PathMatcher1[T1], inner: Function[T1, Route]): Route

def pathSuffix(pm: PathMatcher0, inner: Supplier[Route]): Route

def pathSuffix(segment: String, inner: Supplier[Route]): Route

def pathSuffixTest[T1, T2](pm: PathMatcher2[T1, T2], inner: BiFunction[T1, T2, Route]): Route

def pathSuffixTest[T1](pm: PathMatcher1[T1], inner: Function[T1, Route]): Route

def pathSuffixTest(pm: PathMatcher0, inner: Supplier[Route]): Route

def pathSuffixTest(segment: String, inner: Supplier[Route]): Route

def post(inner: Supplier[Route]): Route

def provide[T](t: T, inner: Function[T, Route]): Route

def put(inner: Supplier[Route]): Route

def rawPathPrefix[T1, T2](pm: PathMatcher2[T1, T2], inner: BiFunction[T1, T2, Route]): Route

def rawPathPrefix[T1](pm: PathMatcher1[T1], inner: Function[T1, Route]): Route

def rawPathPrefix(pm: PathMatcher0, inner: Supplier[Route]): Route

def rawPathPrefix(segment: String, inner: Supplier[Route]): Route

def rawPathPrefixTest[T1, T2](pm: PathMatcher2[T1, T2], inner: BiFunction[T1, T2, Route]): Route

def rawPathPrefixTest[T1](pm: PathMatcher1[T1], inner: Function[T1, Route]): Route

def rawPathPrefixTest(pm: PathMatcher0, inner: Supplier[Route]): Route

def rawPathPrefixTest(segment: String, inner: Supplier[Route]): Route

def recoverRejections(f: Function[Iterable[Rejection], RouteResult], inner: Supplier[Route]): Route

def recoverRejectionsWith(f: Function[Iterable[Rejection], CompletionStage[RouteResult]], inner: Supplier[Route]): Route

def redirect(uri: Uri, redirectionType: StatusCode): Route

def redirectToNoTrailingSlashIfPresent(redirectionType: StatusCode, inner: Supplier[Route]): Route

def redirectToTrailingSlashIfMissing(redirectionType: StatusCode, inner: Supplier[Route]): Route

def reject(): Route

def reject(rejection: Rejection, rejections: Rejection*): Route

def rejectEmptyResponse(inner: Supplier[Route]): Route

def request[T](unmarshaller: Unmarshaller[_ >: HttpRequest, T], inner: Function[T, Route]): Route

def requestEncodedWith(encoding: HttpEncoding, inner: Supplier[Route]): Route

def requestEntityEmpty(inner: Supplier[Route]): Route

def requestEntityPresent(inner: Supplier[Route]): Route

def respondWithDefaultHeader(responseHeader: HttpHeader, inner: Supplier[Route]): Route

def respondWithDefaultHeaders(responseHeaders: Iterable[HttpHeader], inner: Supplier[Route]): Route

def respondWithHeader(responseHeader: HttpHeader, inner: Supplier[Route]): Route

def respondWithHeaders(responseHeaders: Iterable[HttpHeader], inner: Supplier[Route]): Route

def responseEncodingAccepted(encoding: HttpEncoding, inner: Supplier[Route]): Route

def route(alternatives: Route*): Route

def runRoute(route: Route, request: HttpRequest, defaultHostInfo: DefaultHostInfo): TestRouteResult

def runRoute(route: Route, request: HttpRequest): TestRouteResult

def runRouteUnSealed(route: Route, request: HttpRequest, defaultHostInfo: DefaultHostInfo): TestRouteResult

def runRouteUnSealed(route: Route, request: HttpRequest): TestRouteResult

def scheme(name: String, inner: Supplier[Route]): Route

def selectPreferredLanguage(languages: Iterable[Language], inner: Function[Language, Route]): Route

def setCookie(cookies: Iterable[HttpCookie], inner: Supplier[Route]): Route

def setCookie(cookie: HttpCookie, inner: Supplier[Route]): Route

def storeUploadedFile(fieldName: String, destFn: Function[FileInfo, File], inner: BiFunction[FileInfo, File, Route]): Route

def storeUploadedFiles(fieldName: String, destFn: Function[FileInfo, File], inner: Function[List[Entry[FileInfo, File]], Route]): Route

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

def testRoute(first: Route, others: Route*): TestRoute

Wraps a list of route alternatives with testing support.

def toStrictEntity(timeout: FiniteDuration, inner: Supplier[Route]): Route

def toString(): String

def uploadedFile(fieldName: String, inner: BiFunction[FileInfo, File, Route]): Route

def validate(check: BooleanSupplier, errorMsg: String, inner: Supplier[Route]): Route

final def wait(): Unit