Router

abstract val xa: doobie.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]

implicit object HistogramDoubleFormat extends RootJsonFormat[Histogram[Double]]

implicit object HistogramIntFormat extends RootJsonFormat[Histogram[Int]]

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 activateOrganization(platformId: UUID, organizationId: UUID, user: User): Route

def activatePlatform(platformId: UUID, user: User): Route

def activationParams: Directive1[ActivationQueryParameters]

def addDatasourcePermission(datasourceId: UUID): Route

def addOrganizationLogo(orgID: UUID): Route

def addProjectPermission(projectId: UUID): Route

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

def addScenePermission(sceneId: UUID): Route

def addShapePermission(shapeId: UUID): Route

def addToolPermission(toolId: UUID): Route

def addToolRunPermission(toolRunId: UUID): Route

def addUserToOrganization(platformId: UUID, orgId: UUID): Route

def addUserToTeam(platformId: UUID, orgId: UUID, teamId: UUID): Route

def annotationExportQueryParameters: Directive1[AnnotationExportQueryParameters]

def annotationQueryParams: Directive1[AnnotationQueryParameters]

lazy val anonymousUser: Future[Option[User]]

def aoiQueryParameters: Directive1[AoiQueryParameters]

val aoiRoutes: Route

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 auth0ExceptionHandler: ExceptionHandler

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 combinedToolQueryParams: Directive1[CombinedToolQueryParameters]

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

val configRoutes: Route

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

def createAOI(projectId: UUID): Route

def createAnnotation(projectId: UUID): Route

def createAnnotationGroup(projectId: UUID): Route

def createDatasource: Route

def createExport: Route

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

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

def createMapToken: Route

def createOrganization(platformId: UUID): Route

def createPlatform: Route

def createProject: Route

def createProjectLayer(projectId: UUID): Route

def createScene: Route

def createShape: Route

def createTeam(platformId: UUID, orgId: UUID): Route

def createTool: Route

def createToolRun: Route

def createUpload: Route

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

val dataBucket: String

def datasourceQueryParams: Directive1[DatasourceQueryParameters]

val datasourceRoutes: Route

def deactivateOrganization(platformId: UUID, organizationId: UUID, user: User): Route

def deactivatePlatform(platformId: UUID): Route

def decodeRequest: Directive0

def decodeRequestWith(decoders: Decoder*): Directive0

def decodeRequestWith(decoder: Decoder): Directive0

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

def delete: Directive0

def deleteAOI(id: UUID): Route

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 deleteDatasource(datasourceId: UUID): Route

def deleteDatasourcePermissions(datasourceId: UUID): Route

def deleteExport(exportId: UUID): Route

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 deleteMapToken(mapTokenId: UUID): Route

def deleteOrganization(platformId: UUID, orgId: UUID): Route

def deletePlatform(platformId: 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

def deleteScene(sceneId: UUID): Route

def deleteScenePermissions(sceneId: UUID): Route

def deleteShape(shapeId: UUID): Route

def deleteShapePermissions(shapeId: UUID): Route

def deleteTeam(platformId: UUID, orgId: UUID, teamId: UUID): Route

def deleteTool(toolId: UUID): Route

def deleteToolPermissions(toolId: UUID): Route

def deleteToolRun(runId: UUID): Route

def deleteToolRunPermissions(toolRunId: UUID): Route

def deleteUpload(uploadId: UUID): 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 exportFiles(exportId: UUID): Route

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

val exportQueryParams: Directive1[ExportQueryParameters]

val exportRoutes: 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

val featureFlagRoutes: Route

val feedQueryParameters: Directive1[FeedQueryParameters]

val feedRoutes: Route

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 getAOI(id: UUID): Route

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

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

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

def getAuthorizedToken: Route

final def getClass(): Class[_]

def getDatasource(datasourceId: UUID): Route

def getDbOwnUser: Route

def getDownloadUrl(sceneId: UUID): Route

def getDropboxAccessToken: Route

def getExport(exportId: UUID): Route

def getExportDefinition(exportId: UUID): Route

def getFeatureFlags: Route

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 getLicense(shortName: String): Route

def getMapToken(mapTokenId: UUID): Route

def getNameOrFallback(claims: JWTClaimsSet): String

def getOrganization(platformId: UUID, orgId: UUID): Route

def getOrganization(orgId: UUID): Route

def getPlatform(platformId: UUID): Route

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 getProxiedThumbnailImage(thumbnailUri: String): Route

def getScene(sceneId: UUID): Route

def getSceneDatasource(sceneId: UUID): Route

def getShape(shapeId: UUID): Route

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

def getTeam(platformId: UUID, orgId: UUID, teamId: UUID): Route

def getTeam(teamId: UUID): Route

def getThumbnailImage(thumbnailPath: String): Route

def getTool(toolId: UUID): Route

def getToolRun(runId: UUID): Route

def getToolSources(toolId: UUID): Route

def getUpload(uploadId: UUID): Route

def getUploadCredentials(uploadId: UUID): Route

def getUserByEncodedAuthId(authIdEncoded: String): Route

def getUserRoles: Route

def getUserTeams: Route

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]

val healthCheckExceptionHandler: ExceptionHandler

val healthCheckRoutes: Route

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

val licenseRoutes: Route

def listAOIs: Route

def listAOIs(projectId: UUID): Route

def listAnnotationGroups(projectId: UUID): Route

def listAnnotations(projectId: UUID): Route

def listDatasourcePermissions(datasourceId: UUID): Route

def listDatasources: Route

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

def listExports: 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 listLicenses: Route

def listMapTokens: Route

def listOrganizationMembers(platformId: UUID, orgId: UUID): Route

def listPlatformMembers(platformId: UUID): Route

def listPlatformOrganizations(platformId: UUID): Route

def listPlatformUserTeams(platformId: UUID): Route

def listPlatforms: 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 listRefreshTokens: Route

def listScenePermissions(sceneId: UUID): Route

def listScenes: Route

def listShapePermissions(shapeId: UUID): Route

def listShapes: Route

def listTeamMembers(platformId: UUID, orgId: UUID, teamId: UUID): Route

def listTeams(platformId: UUID, organizationId: UUID): Route

def listToolPermissions(toolId: UUID): Route

def listToolRunPermissions(toolRunId: UUID): Route

def listToolRuns: Route

def listTools: Route

def listUploads: Route

def listUserAnalysisActions(analysisId: UUID): Route

def listUserDatasourceActions(datasourceId: UUID): Route

def listUserProjectActions(projectId: UUID): Route

def listUserSceneActions(sceneId: UUID): Route

def listUserShapeActions(shapeId: UUID): Route

def listUserTemplateActions(templateId: UUID): Route

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

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