StandaloneAhcWSRequest

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addCookies(cookies: WSCookie*): Self

def addHttpHeaders(hdrs: (String, String)*): Self

def addQueryStringParameter(parameters: (String, String)*): Self

final def asInstanceOf[T0]: T0

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

val body: WSBody

def buildRequest(): Request

Creates and returns an AHC request, running all operations on it.

val calc: Option[WSSignatureCalculator]

val client: StandaloneAhcWSClient

def clone(): AnyRef

def contentType: Option[String]

val cookies: Seq[WSCookie]

def delete(): Future[Response]

Perform a DELETE on the request asynchronously.

val disableUrlEncoding: Option[Boolean]

final def eq(arg0: AnyRef): Boolean

def execute(): Future[Response]

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

def filterWSRequestExecutor(next: WSRequestExecutor): WSRequestExecutor

def finalize(): Unit

val followRedirects: Option[Boolean]

def get(): Future[Response]

performs a get

def getBody: Option[ByteString]

Returns the body as an array of bytes.

final def getClass(): Class[_]

def head(): Future[Response]

Perform a HEAD on the request asynchronously.

def header(name: String): Option[String]

def headerValues(name: String): Seq[String]

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

def headersToMap(headers: HttpHeaders): TreeMap[String, Seq[String]]

final def isInstanceOf[T0]: Boolean

val method: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def options(): Future[Response]

Perform a OPTIONS on the request asynchronously.

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

Perform a PATCH on the request asynchronously.

def patch[T](body: T)(implicit arg0: BodyWritable[T]): Future[Response]

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

Perform a POST on the request asynchronously.

def post[T](body: T)(implicit arg0: BodyWritable[T]): Future[Response]

val proxyServer: Option[WSProxyServer]

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

Perform a PUT on the request asynchronously.

def put[T](body: T)(implicit arg0: BodyWritable[T]): Future[Response]

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

def requestHeader(name: String): Option[String]

Returns the HTTP header given by name, using the request builder.

def requestHeaders: Map[String, Seq[String]]

Returns the current headers of the request, using the request builder.

def requestQueryParams: Map[String, Seq[String]]

Returns the current query string parameters, using the request builder.

val requestTimeout: Option[Int]

def requestUrl: String

Returns the current URL, using the request builder.

def sign(calc: WSSignatureCalculator): Self

def stream(): Future[StreamedResponse]

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

lazy val uri: URI

val url: String

val virtualHost: Option[String]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withAuth(username: String, password: String, scheme: WSAuthScheme): Self

def withBody[T](body: T)(implicit arg0: BodyWritable[T]): Self

Sets the body for this request.

def withBody(body: WSBody): Self

def withBody(body: File): Self

def withCookies(cookies: WSCookie*): StandaloneWSRequest

def withFollowRedirects(follow: Boolean): Self

def withHttpHeaders(hdrs: (String, String)*): Self

def withMethod(method: String): Self

def withProxyServer(proxyServer: WSProxyServer): Self

def withQueryStringParameters(parameters: (String, String)*): Self

def withRequestFilter(filter: WSRequestFilter): Self

Adds a filter to the request that can transform the request for subsequent filters.

def withRequestTimeout(timeout: Duration): Self

def withVirtualHost(vh: String): Self

def withHeaders(headers: (String, String)*): Self

def withQueryString(parameters: (String, String)*): Self