AuthorizedActionFunction

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

def andThen[Q[_]](other: ActionFunction[[A]AuthInfoRequest[A, U], Q]): ActionFunction[Request, Q]

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

def compose(other: ActionBuilder[Request]): ActionBuilder[[A]AuthInfoRequest[A, U]]

def compose[Q[_]](other: ActionFunction[Q, Request]): ActionFunction[Q, [A]AuthInfoRequest[A, U]]

final def eq(arg0: AnyRef): Boolean

def executionContext: ExecutionContext

def finalize(): Unit

final def getClass(): Class[_]

val handler: ProtectedResourceHandler[U]

def invokeBlock[A](request: Request[A], block: (AuthInfoRequest[A, U]) ⇒ Future[Result]): Future[Result]

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

val tokenEndpoint: TokenEndpoint

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val TooManyRequest: Status