ElasticMQDirectives

implicit abstract def actorSystem: ActorSystem

implicit abstract def materializer: Materializer

abstract def queueManagerActor: ActorRef

implicit abstract def timeout: Timeout

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val DoubleNumber: PathMatcher1[Double]

val JavaUUID: PathMatcher1[UUID]

val Neutral: PathMatcher0

object Segment extends PathMatcher1[String]

def Segments(min: Int, max: Int): PathMatcher1[List[String]]

def Segments(count: Int): PathMatcher1[List[String]]

val Segments: PathMatcher1[List[String]]

def _defaultClassLoader: ClassLoader

implicit def _enhanceRouteWithConcatenation(route: Route): RouteWithConcatenation

implicit def _regex2PathMatcher(regex: Regex): PathMatcher1[String]

implicit def _segmentStringToPathMatcher(segment: String): PathMatcher0

implicit def _string2NR(string: String): NameReceptacle[String]

implicit def _stringExtractionPair2PathMatcher[T](tuple: (String, T)): PathMatcher1[T]

implicit def _stringNameOptionReceptacle2PathMatcher(nr: NameOptionReceptacle[String]): PathMatcher0

implicit def _symbol2NR(symbol: Symbol): NameReceptacle[String]

implicit def _valueMap2PathMatcher[T](valueMap: Map[String, T]): PathMatcher1[T]

def anyParamsMap(body: (Map[String, String]) ⇒ Route): (RequestContext) ⇒ Future[RouteResult]

def as[T](implicit um: FromRequestUnmarshaller[T]): FromRequestUnmarshaller[T]

final def asInstanceOf[T0]: T0

final def asSourceOf[T](support: EntityStreamingSupport)(implicit um: FromByteStringUnmarshaller[T]): RequestToSourceUnmarshaller[T]

final def asSourceOf[T](implicit um: FromByteStringUnmarshaller[T], support: EntityStreamingSupport): RequestToSourceUnmarshaller[T]

def authenticateBasic[T](realm: String, authenticator: Authenticator[T]): AuthenticationDirective[T]

def authenticateBasicAsync[T](realm: String, authenticator: AsyncAuthenticator[T]): AuthenticationDirective[T]

def authenticateBasicPF[T](realm: String, authenticator: AuthenticatorPF[T]): AuthenticationDirective[T]

def authenticateBasicPFAsync[T](realm: String, authenticator: AsyncAuthenticatorPF[T]): AuthenticationDirective[T]

def authenticateOAuth2[T](realm: String, authenticator: Authenticator[T]): AuthenticationDirective[T]

def authenticateOAuth2Async[T](realm: String, authenticator: AsyncAuthenticator[T]): AuthenticationDirective[T]

def authenticateOAuth2PF[T](realm: String, authenticator: AuthenticatorPF[T]): AuthenticationDirective[T]

def authenticateOAuth2PFAsync[T](realm: String, authenticator: AsyncAuthenticatorPF[T]): AuthenticationDirective[T]

def authenticateOrRejectWithChallenge[C <: HttpCredentials, T](authenticator: (Option[C]) ⇒ Future[AuthenticationResult[T]])(implicit arg0: ClassTag[C]): AuthenticationDirective[T]

def authenticateOrRejectWithChallenge[T](authenticator: (Option[HttpCredentials]) ⇒ Future[AuthenticationResult[T]]): AuthenticationDirective[T]

def authorize(check: (RequestContext) ⇒ Boolean): Directive0

def authorize(check: ⇒ Boolean): Directive0

def authorizeAsync(check: (RequestContext) ⇒ Future[Boolean]): Directive0

def authorizeAsync(check: ⇒ Future[Boolean]): Directive0

def cancelRejection(rejection: Rejection): Directive0

def cancelRejections(cancelFilter: (Rejection) ⇒ Boolean): Directive0

def cancelRejections(classes: Class[_]*): Directive0

def checkSameOrigin(allowed: Default): Directive0

def clone(): AnyRef

def complete(m: ⇒ ToResponseMarshallable): StandardRoute

def completeOrRecoverWith(magnet: CompleteOrRecoverWithMagnet): Directive1[Throwable]

def completeWith[T](marshaller: ToResponseMarshaller[T])(inner: ((T) ⇒ Unit) ⇒ Unit): Route

def concat(routes: Route*): Route

def conditional(eTag: Option[EntityTag], lastModified: Option[DateTime]): Directive0

def conditional(eTag: EntityTag, lastModified: DateTime): Directive0

def conditional(lastModified: DateTime): Directive0

def conditional(eTag: EntityTag): Directive0

def cookie(name: String): Directive1[HttpCookiePair]

def decodeRequest: Directive0

def decodeRequestWith(decoders: Decoder*): Directive0

def decodeRequestWith(decoder: Decoder): Directive0

def delete: Directive0

def deleteCookie(name: String, domain: String, path: String): Directive0

def deleteCookie(first: HttpCookie, more: HttpCookie*): Directive0

def encodeResponse: Directive0

def encodeResponseWith(first: Encoder, more: Encoder*): Directive0

def entity[T](um: FromRequestUnmarshaller[T]): Directive1[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val exceptionHandler: ExceptionHandler

val exceptionHandlerPF: PF

def extract[T](f: (RequestContext) ⇒ T): Directive1[T]

def extractActorSystem: Directive1[ActorSystem]

def extractClientIP: Directive1[RemoteAddress]

def extractCredentials: Directive1[Option[HttpCredentials]]

def extractDataBytes: Directive1[Source[ByteString, Any]]

def extractExecutionContext: Directive1[ExecutionContextExecutor]

def extractHost: Directive1[String]

def extractLog: Directive1[LoggingAdapter]

def extractMatchedPath: Directive1[Path]

def extractMaterializer: Directive1[Materializer]

def extractMethod: Directive1[HttpMethod]

def extractOfferedWsProtocols: Directive1[Seq[String]]

def extractParserSettings: Directive1[ParserSettings]

def extractRequest: Directive1[HttpRequest]

def extractRequestContext: Directive1[RequestContext]

def extractRequestEntity: Directive1[RequestEntity]

def extractRequestTimeout: Directive1[Duration]

def extractScheme: Directive1[String]

def extractSettings: Directive1[RoutingSettings]

def extractStrictEntity(timeout: FiniteDuration, maxBytes: Long): Directive1[Strict]

def extractStrictEntity(timeout: FiniteDuration): Directive1[Strict]

def extractUnmatchedPath: Directive1[Path]

def extractUpgradeToWebSocket: Directive1[UpgradeToWebSocket]

def extractUri: Directive1[Uri]

def failWith(error: Throwable): StandardRoute

def fileUpload(fieldName: String): Directive1[(FileInfo, Source[ByteString, Any])]

def fileUploadAll(fieldName: String): Directive1[Seq[(FileInfo, Source[ByteString, Any])]]

def finalize(): Unit

def formField(pdm: FieldMagnet): Out

def formFieldMap: Directive1[Map[String, String]]

def formFieldMultiMap: Directive1[Map[String, List[String]]]

def formFieldSeq: Directive1[Seq[(String, String)]]

def formFields(pdm: FieldMagnet): Out

implicit def futureRouteToRoute(futureRoute: Future[Route]): Route

def get: Directive0

final def getClass(): Class[_]

def getFromBrowseableDirectories(directories: String*)(implicit renderer: DirectoryRenderer, resolver: ContentTypeResolver): Route

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

def getFromDirectory(directoryName: String)(implicit resolver: ContentTypeResolver): Route

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

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

def getFromFile(fileName: String)(implicit resolver: ContentTypeResolver): Route

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

def getFromResource(resourceName: String)(implicit resolver: ContentTypeResolver): Route

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

def handleExceptions(handler: ExceptionHandler): Directive0

def handleRejections(handler: RejectionHandler): Directive0

def handleRejectionsWithSQSError: Directive0

def handleSQSException(e: SQSException): Route

def handleServerExceptions: Directive0

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

def handleWebSocketMessagesForOptionalProtocol(handler: Flow[Message, Message, Any], subprotocol: Option[String]): Route

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

def handleWith[A, B](f: (A) ⇒ B)(implicit um: FromRequestUnmarshaller[A], m: ToResponseMarshaller[B]): Route

def hashCode(): Int

def head: Directive0

def headerValue[T](f: (HttpHeader) ⇒ Option[T]): Directive1[T]

def headerValueByName(headerName: String): Directive1[String]

def headerValueByName(headerName: Symbol): Directive1[String]

def headerValueByType[T](magnet: HeaderMagnet[T]): Directive1[T]

def headerValuePF[T](pf: PartialFunction[HttpHeader, T]): Directive1[T]

def host(regex: Regex): Directive1[String]

def host(predicate: (String) ⇒ Boolean): Directive0

def host(hostNames: String*): Directive0

def ignoreTrailingSlash: Directive0

def instanceOf[T](implicit m: ToResponseMarshaller[T]): ToResponseMarshaller[T]

final def isInstanceOf[T0]: Boolean

def isValidFifoPropertyValue(propValue: String): Boolean

Valid values are alphanumeric characters and punctuation (!"#$%&'()*+,-./:;<=>?@[\]^_{|}~). The maximum length is 128 characters

def listDirectoryContents(directories: String*)(implicit renderer: DirectoryRenderer): Route

def logRequest(magnet: LoggingMagnet[(HttpRequest) ⇒ Unit]): Directive0

def logRequestResult(magnet: LoggingMagnet[(HttpRequest) ⇒ (RouteResult) ⇒ Unit]): Directive0

def logResult(magnet: LoggingMagnet[(RouteResult) ⇒ Unit]): Directive0

lazy val logger: Logger

def mapInnerRoute(f: (Route) ⇒ Route): Directive0

def mapRejections(f: (Seq[Rejection]) ⇒ Seq[Rejection]): Directive0

def mapRequest(f: (HttpRequest) ⇒ HttpRequest): Directive0

def mapRequestContext(f: (RequestContext) ⇒ RequestContext): Directive0

def mapResponse(f: (HttpResponse) ⇒ HttpResponse): Directive0

def mapResponseEntity(f: (ResponseEntity) ⇒ ResponseEntity): Directive0

def mapResponseHeaders(f: (Seq[HttpHeader]) ⇒ Seq[HttpHeader]): Directive0

def mapRouteResult(f: (RouteResult) ⇒ RouteResult): Directive0

def mapRouteResultFuture(f: (Future[RouteResult]) ⇒ Future[RouteResult]): Directive0

def mapRouteResultPF(f: PartialFunction[RouteResult, RouteResult]): Directive0

def mapRouteResultWith(f: (RouteResult) ⇒ Future[RouteResult]): Directive0

def mapRouteResultWithPF(f: PartialFunction[RouteResult, Future[RouteResult]]): Directive0

def mapSettings(f: (RoutingSettings) ⇒ RoutingSettings): Directive0

def mapUnmatchedPath(f: (Path) ⇒ Path): Directive0

implicit def messageDispatcher: ExecutionContextExecutor

def method(httpMethod: HttpMethod): Directive0

final def ne(arg0: AnyRef): Boolean

def nothingMatcher[L](implicit arg0: Tuple[L]): PathMatcher[L]

final def notify(): Unit

final def notifyAll(): Unit

def onComplete[T](future: ⇒ Future[T]): Directive1[Try[T]]

def onCompleteWithBreaker[T](breaker: CircuitBreaker)(future: ⇒ Future[T]): Directive1[Try[T]]

def onSuccess(magnet: OnSuccessMagnet): Directive[Out]

def optionalCookie(name: String): Directive1[Option[HttpCookiePair]]

def optionalHeaderValue[T](f: (HttpHeader) ⇒ Option[T]): Directive1[Option[T]]

def optionalHeaderValueByName(headerName: String): Directive1[Option[String]]

def optionalHeaderValueByName(headerName: Symbol): Directive1[Option[String]]

def optionalHeaderValueByType[T <: HttpHeader](magnet: HeaderMagnet[T]): Directive1[Option[T]]

def optionalHeaderValuePF[T](pf: PartialFunction[HttpHeader, T]): Directive1[Option[T]]

def options: Directive0

def overrideMethodWithParameter(paramName: String): Directive0

def parameter(pdm: ParamMagnet): Out

def parameterMap: Directive1[Map[String, String]]

def parameterMultiMap: Directive1[Map[String, List[String]]]

def parameterSeq: Directive1[Seq[(String, String)]]

def parameters(pdm: ParamMagnet): Out

def pass: Directive0

def patch: Directive0

def path[L](pm: PathMatcher[L]): Directive[L]

def pathEnd: Directive0

def pathEndOrSingleSlash: Directive0

def pathPrefix[L](pm: PathMatcher[L]): Directive[L]

def pathPrefixTest[L](pm: PathMatcher[L]): Directive[L]

def pathSingleSlash: Directive0

def pathSuffix[L](pm: PathMatcher[L]): Directive[L]

def pathSuffixTest[L](pm: PathMatcher[L]): Directive[L]

def post: Directive0

def provide[T](value: T): Directive1[T]

def put: Directive0

def queueActorAndDataFromRequest(p: AnyParams)(body: (ActorRef, QueueData) ⇒ Route): Route

def queueActorAndNameFromRequest(p: AnyParams)(body: (ActorRef, String) ⇒ Route): Route

def queueActorFromRequest(p: AnyParams)(body: (ActorRef) ⇒ Route): Route

def queueDataFromParams(p: AnyParams)(body: (QueueData) ⇒ Route): Route

def queueNameFromParams(p: AnyParams): Directive1[String]

def rawPathPrefix[L](pm: PathMatcher[L]): Directive[L]

def rawPathPrefixTest[L](pm: PathMatcher[L]): Directive[L]

def recoverRejections(f: (Seq[Rejection]) ⇒ RouteResult): Directive0

def recoverRejectionsWith(f: (Seq[Rejection]) ⇒ Future[RouteResult]): Directive0

def redirect(uri: Uri, redirectionType: Redirection): StandardRoute

def redirectToNoTrailingSlashIfPresent(redirectionType: Redirection): Directive0

def redirectToTrailingSlashIfMissing(redirectionType: Redirection): Directive0

def reject(rejections: Rejection*): StandardRoute

def reject: StandardRoute

def rejectEmptyResponse: Directive0

val rejectionHandler: RejectionHandler

def requestEncodedWith(encoding: HttpEncoding): Directive0

def requestEntityEmpty: Directive0

def requestEntityPresent: Directive0

def respondWith(statusCode: Int)(elem: Elem): Route

def respondWith(elem: Elem): Route

def respondWithDefaultHeader(responseHeader: HttpHeader): Directive0

def respondWithDefaultHeaders(responseHeaders: Seq[HttpHeader]): Directive0

def respondWithDefaultHeaders(responseHeaders: HttpHeader*): Directive0

def respondWithHeader(responseHeader: HttpHeader): Directive0

def respondWithHeaders(responseHeaders: Seq[HttpHeader]): Directive0

def respondWithHeaders(responseHeaders: HttpHeader*): Directive0

def responseEncodingAccepted(encoding: HttpEncoding): Directive0

def rootPath(body: Route): Route

def scheme(name: String): Directive0

def selectPreferredLanguage(first: Language, more: Language*): Directive1[Language]

def separateOnSlashes(string: String): PathMatcher0

def setCookie(first: HttpCookie, more: HttpCookie*): Directive0

def storeUploadedFile(fieldName: String, destFn: (FileInfo) ⇒ File): Directive[(FileInfo, File)]

def storeUploadedFiles(fieldName: String, destFn: (FileInfo) ⇒ File): Directive1[Seq[(FileInfo, File)]]

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

def textract[L](f: (RequestContext) ⇒ L)(implicit arg0: Tuple[L]): Directive[L]

def toStrictEntity(timeout: FiniteDuration, maxBytes: Long): Directive0

def toStrictEntity(timeout: FiniteDuration): Directive0

def toString(): String

def tprovide[L](values: L)(implicit arg0: Tuple[L]): Directive[L]

def validate(check: ⇒ Boolean, errorMsg: String): Directive0

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withExecutionContext(ec: ExecutionContextExecutor): Directive0

def withLog(log: LoggingAdapter): Directive0

def withMaterializer(materializer: Materializer): Directive0

def withPrecompressedMediaTypeSupport: Directive0

def withRangeSupport: Directive0

def withRequestTimeout(timeout: Duration, handler: Option[(HttpRequest) ⇒ HttpResponse]): Directive0

def withRequestTimeout(timeout: Duration, handler: (HttpRequest) ⇒ HttpResponse): Directive0

def withRequestTimeout(timeout: Duration): Directive0

def withRequestTimeoutResponse(handler: (HttpRequest) ⇒ HttpResponse): Directive0

def withSettings(settings: RoutingSettings): Directive0

def withSizeLimit(maxBytes: Long): Directive0

def withoutRequestTimeout: Directive0

def withoutSizeLimit: Directive0

def uploadedFile(fieldName: String): Directive1[(FileInfo, File)]