SjCrudInterface

abstract val configService: GenericMongoService[ConfigurationSetting]

implicit abstract def executor: ExecutionContextExecutor

abstract val fileMetadataDAO: GenericMongoService[FileMetadata]

abstract val instanceDAO: GenericMongoService[Instance]

abstract val logger: LoggingAdapter

implicit abstract val materializer: Materializer

abstract val providerDAO: GenericMongoService[Provider]

abstract val restHost: String

abstract val restPort: Int

abstract val serializer: Serializer

abstract val serviceDAO: GenericMongoService[Service]

abstract val storage: FileStorage

abstract val streamDAO: GenericMongoService[SjStream]

implicit abstract val system: ActorSystem

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

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]]

lazy val allowedOriginHeader: Access-Control-Allow-Origin

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

final def asInstanceOf[T0]: T0

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 cancelRejection(rejection: Rejection): Directive0

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

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

def challengeFor(realm: String): HttpChallenge

def checkContext(ctx: RequestContext): Unit

def checkJarFile(jarFile: File): Map[String, Any]

Check specification of uploading jar file

def checkSpecification(jarFile: File): Boolean

Check specification of uploading custom jar file

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 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

val configSettingsApi: Route

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

def corsHandler(r: Route): Route

def createMessage(name: String, params: String*): String

val customApi: Route

def decodeRequest: Directive0

def decodeRequestWith(decoders: Decoder*): Directive0

def decodeRequestWith(decoder: Decoder): Directive0

def defaultClassLoader: ClassLoader

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

implicit def enhanceRouteWithConcatenation(route: Route): RouteWithConcatenation

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

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

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

def ensuring(cond: Boolean): SjCrudInterface

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val exceptionHandler: ExceptionHandler

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

def extractClientIP: Directive1[RemoteAddress]

def extractCredentials: Directive1[Option[HttpCredentials]]

def extractExecutionContext: Directive1[ExecutionContext]

def extractHost: Directive1[String]

def extractLog: Directive1[LoggingAdapter]

def extractMaterializer: Directive1[Materializer]

def extractMethod: Directive1[HttpMethod]

def extractOfferedWsProtocols: Directive1[Seq[String]]

def extractRequest: Directive1[HttpRequest]

def extractRequestContext: Directive1[RequestContext]

def extractScheme: Directive1[String]

def extractSettings: Directive1[RoutingSettings]

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 finalize(): Unit

def formField(pdm: FieldMagnet): Out

def formFields(pdm: FieldMagnet): Out

def formatted(fmtstr: String): String

def get: Directive0

final def getClass(): Class[_]

def getEntityFromContext(ctx: RequestContext): String

Getting entity from HTTP-request

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 getMessage(name: String): String

def getSpecification(jarFile: File): Map[String, Any]

def handleExceptions(handler: ExceptionHandler): Directive0

def handleRejections(handler: RejectionHandler): 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 <: HttpHeader](magnet: ClassMagnet[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 instanceOf[T](implicit m: ToResponseMarshaller[T]): ToResponseMarshaller[T]

final def isInstanceOf[T0]: Boolean

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

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

def method(httpMethod: HttpMethod): Directive0

val modulesApi: Route

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 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: ClassMagnet[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]

val providersApi: Route

def put: Directive0

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

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

def reject(rejections: Rejection*): StandardRoute

def reject: StandardRoute

def rejectEmptyResponse: Directive0

def requestEncodedWith(encoding: HttpEncoding): Directive0

def requestEntityEmpty: Directive0

def requestEntityPresent: Directive0

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 restResponseToHttpResponse(restResponse: RestResponse): HttpResponse

def route(): Route

def scheme(name: String): Directive0

implicit def segmentStringToPathMatcher(segment: String): PathMatcher0

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

def separateOnSlashes(string: String): PathMatcher0

val servicesApi: Route

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

val streamsApi: Route

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]

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

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

def toString(): String

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

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

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withExecutionContext(ec: ExecutionContext): Directive0

def withLog(log: LoggingAdapter): Directive0

def withMaterializer(materializer: Materializer): Directive0

def withRangeSupport: Directive0

def withSettings(settings: RoutingSettings): Directive0

def →[B](y: B): (SjCrudInterface, B)