WSRequest

abstract val auth: Option[(String, String, WSAuthScheme)]

The authentication this request should use

abstract val body: WSBody

The body of this request

abstract val calc: Option[WSSignatureCalculator]

A calculator of the signature for this request

abstract def execute(): Future[WSResponse]

Execute this request

abstract val followRedirects: Option[Boolean]

Whether this request should follow redirects

abstract val headers: Map[String, Seq[String]]

The headers for this request

abstract val method: String

The method for this request

abstract val proxyServer: Option[WSProxyServer]

The proxy server this request will use

abstract val queryString: Map[String, Seq[String]]

The query string for this request

abstract val requestTimeout: Option[Int]

The timeout for the request

abstract def sign(calc: WSSignatureCalculator): WSRequest

sets the signature calculator for the request

abstract def stream(): Future[(WSResponseHeaders, Enumerator[Array[Byte]])]

Execute this request and stream the response body in an enumerator

abstract val url: String

The base URL for this request

abstract val virtualHost: Option[String]

The virtual host this request will use

abstract def withAuth(username: String, password: String, scheme: WSAuthScheme): WSRequest

sets the authentication realm

abstract def withBody(body: WSBody): WSRequest

Sets the body for this request

abstract def withFollowRedirects(follow: Boolean): WSRequest

Sets whether redirects (301, 302) should be followed automatically

abstract def withHeaders(hdrs: (String, String)*): WSRequest

adds any number of HTTP headers

abstract def withMethod(method: String): WSRequest

Sets the method for this request

abstract def withProxyServer(proxyServer: WSProxyServer): WSRequest

Sets the proxy server to use in this request

abstract def withQueryString(parameters: (String, String)*): WSRequest

adds any number of query string parameters to the

abstract def withRequestTimeout(timeout: Long): WSRequest

Sets the maximum time in milliseconds you expect the request to take.

abstract def withVirtualHost(vh: String): WSRequest

Sets the virtual host to use in this request

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def delete(): Future[WSResponse]

Perform a DELETE on the request asynchronously.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def execute(method: String): Future[WSResponse]

def finalize(): Unit

def get[A](consumer: (WSResponseHeaders) ⇒ Iteratee[Array[Byte], A])(implicit ec: ExecutionContext): Future[Iteratee[Array[Byte], A]]

performs a get

def get(): Future[WSResponse]

performs a get

final def getClass(): Class[_]

def getStream(): Future[(WSResponseHeaders, Enumerator[Array[Byte]])]

performs a get

def hashCode(): Int

def head(): Future[WSResponse]

Perform a HEAD on the request asynchronously.

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def options(): Future[WSResponse]

Perform a OPTIONS on the request asynchronously.

def patch(body: File): Future[WSResponse]

Perform a PATCH on the request asynchronously.

def patch[T](body: T)(implicit wrt: Writeable[T]): Future[WSResponse]

Perform a PATCH on the request asynchronously.

def patchAndRetrieveStream[A, T](body: T)(consumer: (WSResponseHeaders) ⇒ Iteratee[Array[Byte], A])(implicit wrt: Writeable[T], ec: ExecutionContext): Future[Iteratee[Array[Byte], A]]

performs a POST with supplied body

def post(body: File): Future[WSResponse]

Perform a POST on the request asynchronously.

def post[T](body: T)(implicit wrt: Writeable[T]): Future[WSResponse]

Perform a POST on the request asynchronously.

def postAndRetrieveStream[A, T](body: T)(consumer: (WSResponseHeaders) ⇒ Iteratee[Array[Byte], A])(implicit wrt: Writeable[T], ec: ExecutionContext): Future[Iteratee[Array[Byte], A]]

performs a POST with supplied body

def put(body: File): Future[WSResponse]

Perform a PUT on the request asynchronously.

def put[T](body: T)(implicit wrt: Writeable[T]): Future[WSResponse]

Perform a PUT on the request asynchronously.

def putAndRetrieveStream[A, T](body: T)(consumer: (WSResponseHeaders) ⇒ Iteratee[Array[Byte], A])(implicit wrt: Writeable[T], ec: ExecutionContext): Future[Iteratee[Array[Byte], A]]

performs a PUT with supplied body

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

def toString(): String

lazy val uri: URI

The URI for this request

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withBody[T](body: T)(implicit wrt: Writeable[T]): WSRequest

Sets the body for this request