ProjectRoutes

abstract val xa: Transactor[IO]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val BULK_OPERATION_MAX_LIMIT: Int

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 acceptScene(projectId: UUID, sceneId: UUID): Route

def acceptScenes(projectId: UUID): Route

def activationParams: Directive1[ActivationQueryParameters]

def addProjectPermission(projectId: UUID): Route

def addProjectScenes(projectId: UUID, layerIdO: Option[UUID] = None): Route

def annotationExportQueryParameters: Directive1[AnnotationExportQueryParameters]

def annotationQueryParams: Directive1[AnnotationQueryParameters]

lazy val anonymousUser: Future[Option[User]]

def aoiQueryParameters: Directive1[AoiQueryParameters]

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]

val auth0Bearer: String

val auth0ClientId: String

val auth0Domain: String

val auth0ManagementClientId: String

val auth0ManagementSecret: String

def authenticate: Directive1[User]

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 authenticateSuperUser: Directive1[User]

def authenticateWithParameter: Directive1[User]

def authenticateWithToken(tokenString: String): Directive1[User]

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

def authorize(check: ⇒ Boolean): Directive0

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

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

val awsbatchConfig: awsbatch.type

val batchClient: AWSBatch

def cancelRejection(rejection: Rejection): Directive0

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

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

lazy val challenge: HttpChallenge

def checkSameOrigin(allowed: Default): Directive0

def circeDecodingError: ExceptionHandler

val clientEnvironment: String

def clone(): AnyRef

val cogMissingHandler: ExceptionHandler

def complete(m: ⇒ ToResponseMarshallable): StandardRoute

def completeOrFail(magnet: CompleteOrRecoverWithMagnet): (RequestContext) ⇒ Future[RouteResult]

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

def completeSingleOrNotFound(count: Int): StandardRoute

def completeSomeOrNotFound(count: Int): StandardRoute

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

def completeWithOneOrFail(future: ⇒ Future[Int]): (RequestContext) ⇒ Future[RouteResult]

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

val config: Config

val configAuth: Config

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

def createAOI(projectId: UUID): Route

def createAnnotation(projectId: UUID): Route

def createAnnotationGroup(projectId: UUID): Route

def createLayerAnnotation(projectId: UUID, layerId: UUID): Route

def createLayerAnnotationGroup(projectId: UUID, layerId: UUID): Route

def createProject: Route

def createProjectLayer(projectId: UUID): Route

def createUserWithRoles(userId: String, email: String, name: String, picture: String, jwtClaims: JWTClaimsSet): doobie.ConnectionIO[(User, List[UserGroupRole])]

val dataBucket: String

def decodeRequest: Directive0

def decodeRequestWith(decoders: Decoder*): Directive0

def decodeRequestWith(decoder: Decoder): Directive0

def defaultPersonalInfo(user: User, claims: JWTClaimsSet): PersonalInfo

def delete: Directive0

def deleteAnnotation(projectId: UUID, annotationId: UUID): Route

def deleteAnnotationGroup(projectId: UUID, agId: UUID): Route

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

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

def deleteLayerAnnotation(projectId: UUID, annotationId: UUID, layerId: UUID): Route

def deleteLayerAnnotationGroup(projectId: UUID, layerId: UUID, agId: UUID): Route

def deleteLayerAnnotations(projectId: UUID, layerId: UUID): Route

def deleteProject(projectId: UUID): Route

def deleteProjectAnnotations(projectId: UUID): Route

def deleteProjectLayer(projectId: UUID, layerId: UUID): Route

def deleteProjectPermissions(projectId: UUID): Route

def deleteProjectScenes(projectId: UUID, layerIdO: Option[UUID] = None): Route

implicit val deserializerGroupType: Unmarshaller[String, GroupType]

implicit val deserializerTimestamp: Unmarshaller[String, Timestamp]

implicit val deserializerUUID: Unmarshaller[String, UUID]

val dropboxClientId: String

def encodeResponse: Directive0

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

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

val environment: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exportAnnotationShapefile(projectId: UUID): Route

def exportLayerAnnotationShapefile(projectId: UUID, layerId: UUID): Route

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 extractMapTokenParam: Directive1[Option[UUID]]

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 extractTokenHeader: Directive1[Option[String]]

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

def get: Directive0

def getAnnotation(projectId: UUID, annotationId: UUID): Route

def getAnnotationGroup(projectId: UUID, agId: UUID): Route

def getAnnotationGroupSummary(projectId: UUID, annotationGroupId: UUID): Route

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 getLayerAnnotation(projectId: UUID, annotationId: UUID, layerId: UUID): Route

def getLayerAnnotationGroup(projectId: UUID, layerId: UUID, agId: UUID): Route

def getLayerAnnotationGroupSummary(projectId: UUID, layerId: UUID, annotationGroupId: UUID): Route

def getNameOrFallback(claims: JWTClaimsSet): String

def getProject(projectId: UUID): Route

def getProjectLayer(projectId: UUID, layerId: UUID): Route

def getProjectLayerMosaicDefinition(projectId: UUID, layerId: UUID): Route

def getProjectLayerSceneColorCorrectParams(projectId: UUID, layerId: UUID, sceneId: UUID): Route

def getProjectLayerSceneCounts(projectId: UUID): Route

def getProjectMosaicDefinition(projectId: UUID): (RequestContext) ⇒ Future[RouteResult]

Get the information which defines mosaicing behavior for each scene in a given project

def getProjectSceneColorCorrectParams(projectId: UUID, sceneId: UUID): (RequestContext) ⇒ Future[RouteResult]

Get the color correction paramters for a project/scene pairing

def getStringClaimOrBlank(claims: JWTClaimsSet, key: String): String

def groupQueryParameters: Directive1[GroupQueryParameters]

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

val httpHost: String

val httpPort: Int

def ignoreTrailingSlash: Directive0

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

val intercomAppId: String

final def isInstanceOf[T0]: Boolean

def kickoffAOIUpdateProject(projectId: UUID): Unit

def kickoffProjectExport(exportId: UUID): Unit

def kickoffSceneImport(uploadId: UUID): Unit

def kickoffSceneIngest(sceneId: UUID): Unit

def listAOIs(projectId: UUID): Route

def listAnnotationGroups(projectId: UUID): Route

def listAnnotations(projectId: UUID): Route

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

def listLabels(projectId: UUID): Route

def listLayerAnnotationGroups(projectId: UUID, layerId: UUID): Route

def listLayerAnnotations(projectId: UUID, layerId: UUID): Route

def listLayerDatasources(projectId: UUID, layerId: UUID): Route

def listLayerLabels(projectId: UUID, layerId: UUID): Route

def listLayerScenes(projectId: UUID, layerId: UUID): Route

def listProjectDatasources(projectId: UUID): Route

def listProjectLayers(projectId: UUID): Route

def listProjectPermissions(projectId: UUID): Route

def listProjectScenes(projectId: UUID): Route

def listProjects: Route

def listUserProjectActions(projectId: UUID): 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

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 orgQueryParams: Directive1[OrgQueryParameters]

def overrideMethodWithParameter(paramName: String): Directive0

def ownerQueryParameters: Directive1[OwnerQueryParameters]

def ownershipTypeQueryParameters: Directive1[OwnershipTypeQueryParameters]

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 platformIdParams: Directive1[PlatformIdQueryParameters]

def post: Directive0

def processShapefile(projectId: UUID, tempFile: File, fileMetadata: FileInfo, propsO: Option[Map[String, String]] = None, projectLayerIdO: Option[UUID]): Route

def processShapefileImport(matches: Iterator[File], prj: Iterator[File], props: Map[String, String], user: User, projectId: UUID, projectLayerIdO: Option[UUID]): Route

def processShapefileUpload(matches: Iterator[File]): List[String]

def projectAuthFromMapTokenO(mapTokenO: Option[UUID], projectId: UUID): Directive0

def projectAuthFromTokenO(tokenO: Option[String], projectId: UUID, analysisId: Option[UUID] = None): Directive0

def projectIsPublic(projectId: UUID): Directive0

def projectQueryParameters: Directive1[ProjectQueryParameters]

val projectRoutes: Route

val projectSceneQueryParameters: Directive1[ProjectSceneQueryParameters]

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

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

val region: String

def reject(rejections: Rejection*): StandardRoute

def reject: StandardRoute

def rejectEmptyResponse: Directive0

def replaceProjectPermissions(projectId: UUID): Route

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

val rollbarApiToken: String

val rollbarClient: Rollbar

val rollbarClientToken: String

val sceneQueryParameters: Directive1[CombinedSceneQueryParams]

val sceneSearchModeQueryParams: Directive1[SceneSearchModeQueryParams]

val sceneSpecificQueryParams: Directive1[SceneQueryParameters]

def scheme(name: String): Directive0

val scopedUploadRoleArn: String

def searchParams: Directive1[SearchQueryParameters]

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

def sendError(s: String): Unit

def sendError(e: Throwable): Unit

def separateOnSlashes(string: String): PathMatcher0

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

def setProjectColorMode(projectId: UUID): (RequestContext) ⇒ Future[RouteResult]

def setProjectLayerColorMode(projectId: UUID, layerId: UUID): (RequestContext) ⇒ Future[RouteResult]

def setProjectLayerSceneColorCorrectParams(projectId: UUID, layerId: UUID, sceneId: UUID): Route

def setProjectLayerSceneOrder(projectId: UUID, layerId: UUID): Route

def setProjectLayerScenesColorCorrectParams(projectId: UUID, layerId: UUID): Route

def setProjectSceneColorCorrectParams(projectId: UUID, sceneId: UUID): (RequestContext) ⇒ Future[RouteResult]

Set color correction parameters for a project/scene pairing

def setProjectSceneOrder(projectId: UUID): Route

Set the manually defined z-ordering for scenes within a given project

def setProjectScenesColorCorrectParams(projectId: UUID): (RequestContext) ⇒ Future[RouteResult]

Set color correction parameters for a list of scenes

def shapeQueryParams: Directive1[ShapeQueryParameters]

def splitProjectLayer(projectId: UUID, layerId: UUID): Route

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

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

def submitJobRequest(jobDefinition: String, jobQueueName: String, parameters: Map[String, String], jobName: String): Unit

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

def tagQueryParameters: Directive1[TagQueryParameters]

def teamQueryParameters: Directive1[TeamQueryParameters]

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

val thumbnailBucket: String

val tileServerLocation: String

def timestampQueryParameters: Directive1[TimestampQueryParameters]

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