OAuth2AsyncProvider

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val Accepted: Status

val BadGateway: Status

val BadRequest: Status

val Conflict: Status

val Created: Status

val EntityTooLarge: Status

val ExpectationFailed: Status

val FailedDependency: Status

val Forbidden: Status

def Found(url: String): Result

val GatewayTimeout: Status

val Gone: Status

val HttpVersionNotSupported: Status

val InsufficientStorage: Status

val InternalServerError: Status

val Locked: Status

val MethodNotAllowed: Status

def MovedPermanently(url: String): Result

val MultiStatus: Status

val NoContent: Result

val NonAuthoritativeInformation: Status

val NotAcceptable: Status

val NotFound: Status

val NotImplemented: Status

val NotModified: Result

val Ok: Status

val PartialContent: Status

val PaymentRequired: Status

def PermanentRedirect(url: String): Result

val PreconditionFailed: Status

def Redirect(call: Call, status: Int): Result

def Redirect(call: Call): Result

def Redirect(url: String, queryString: Map[String, Seq[String]], status: Int): Result

def Redirect(url: String, status: Int): Result

val RequestTimeout: Status

val ResetContent: Result

def SeeOther(url: String): Result

val ServiceUnavailable: Status

def Status(code: Int): Status

def TemporaryRedirect(url: String): Result

val TooManyRequests: Status

val Unauthorized: Status

val UnprocessableEntity: Status

val UnsupportedMediaType: Status

val UriTooLong: Status

final def asInstanceOf[T0]: T0

def authorize[A, U](handler: ProtectedResourceHandler[U])(callback: (AuthInfo[U]) ⇒ Future[Result])(implicit request: Request[A], ctx: ExecutionContext): Future[Result]

Authorize to already created access token in ProtectedResourceHandler process and return the response to client.

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def issueAccessToken[A, U](handler: AuthorizationHandler[U])(implicit request: Request[A], ctx: ExecutionContext): Future[Result]

Issue access token in AuthorizationHandler process and return the response to client.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit def play2oauthRequest[A](request: Request[A]): AuthorizationRequest

implicit def play2oauthRequest(request: RequestHeader): AuthorizationRequest

implicit def play2protectedResourceRequest[A](request: Request[A]): ProtectedResourceRequest

implicit def play2protectedResourceRequest(request: RequestHeader): ProtectedResourceRequest

val protectedResource: ProtectedResource

def responseAccessToken[U](r: GrantHandlerResult[U]): Map[String, JsValue]

def responseOAuthErrorHeader(e: OAuthError): (String, String)

def responseOAuthErrorJson(e: OAuthError): JsValue

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

def toOAuthErrorString(e: OAuthError): String

def toString(): String

val tokenEndpoint: TokenEndpoint

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val TooManyRequest: Status