AhcWSRequest

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 addQueryStringParameters(parameters: (String, String)*): Self

final def asInstanceOf[T0]: T0

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

The authentication this request should use

def body: WSBody

The body of this request

def body(objectMapper: ObjectMapper): BodyWritable[JsonNode]

implicit val bodyWritableOf_Multipart: BodyWritable[Source[Part[Source[ByteString, _]], _]]

def calc: Option[WSSignatureCalculator]

A calculator of the signature for this request

def clone(): AnyRef

def contentType: Option[String]

def cookies: Seq[WSCookie]

The cookies for this request

def delete(): Future[Response]

final def eq(arg0: AnyRef): Boolean

def execute(): Future[Response]

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

def finalize(): Unit

def followRedirects: Option[Boolean]

Whether this request should follow redirects

def get(): Future[Response]

final def getClass(): Class[_]

def head(): Future[Response]

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

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

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

The headers for this request

final def isInstanceOf[T0]: Boolean

def method: String

The method for this request

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def options(): Future[Response]

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

Perform a PATCH on the request asynchronously.

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

Perform a POST on the request asynchronously.

def proxyServer: Option[WSProxyServer]

The proxy server this request will use

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

Perform a PUT on the request asynchronously.

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

The query string for this request

def requestTimeout: Option[Int]

The timeout for the request

def sign(calc: WSSignatureCalculator): Self

def stream(): Future[Response]

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

val underlying: StandaloneAhcWSRequest

def uri: URI

The URI for this request

def url: String

The base URL for this request

def virtualHost: Option[String]

The virtual host this request will use

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

def withCookies(cookies: WSCookie*): Self

def withFollowRedirects(follow: Boolean): Self

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

def withMethod(method: String): Self

def withProxyServer(proxyServer: WSProxyServer): Self

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

def withRequestFilter(filter: WSRequestFilter): Self

def withRequestTimeout(timeout: Duration): Self

def withVirtualHost(vh: String): Self

implicit val writableOf_File: BodyWritable[File]

implicit val writableOf_InputStream: BodyWritable[Supplier[InputStream]]

implicit val writableOf_Source: BodyWritable[Source[ByteString, _]]

implicit val writeableOf_ByteArray: BodyWritable[Array[Byte]]

implicit val writeableOf_ByteBuffer: BodyWritable[ByteBuffer]

implicit val writeableOf_Bytes: BodyWritable[ByteString]

implicit val writeableOf_Document: BodyWritable[Document]

implicit val writeableOf_JsValue: BodyWritable[JsValue]

implicit val writeableOf_NodeBuffer: BodyWritable[NodeBuffer]

implicit def writeableOf_NodeSeq[C <: NodeSeq]: BodyWritable[C]

implicit val writeableOf_String: BodyWritable[String]

implicit val writeableOf_StringBuilder: BodyWritable[StringBuilder]

implicit val writeableOf_WsBody: BodyWritable[WSBody]

implicit val writeableOf_urlEncodedForm: BodyWritable[Map[String, Seq[String]]]

implicit val writeableOf_urlEncodedSimpleForm: BodyWritable[Map[String, String]]

def patch(body: Source[Part[Source[ByteString, _]], _]): Future[WSResponse]

Perform a PATCH on the request asynchronously.

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

Perform a PATCH on the request asynchronously.

def post(body: Source[Part[Source[ByteString, _]], _]): Future[WSResponse]

Performs a POST on the request asynchronously.

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

Perform a POST on the request asynchronously.

def put(body: Source[Part[Source[ByteString, _]], _]): Future[WSResponse]

Perform a PUT on the request asynchronously.

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

Perform a PUT on the request asynchronously.

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

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